Add decodeEvents function

account-contract-artifacts/ArgentAccount/0.2.2/ArgentAccount.cairo/ArgentAccount.json

@@ -779,11 +779,7 @@
                 "value": "guardian signature invalid"
             }
         ],
-        "builtins": [
-            "pedersen",
-            "range_check",
-            "ecdsa"
-        ],
+        "builtins": ["pedersen", "range_check", "ecdsa"],
         "data": [
             "0x40780017fff7fff",
             "0x1",

scripts/test.sh

@@ -9,7 +9,7 @@ CONFIG_FILE_NAME="hardhat.config.ts"
 
 # setup example repo
 rm -rf starknet-hardhat-example
-git clone -b plugin --single-branch git@github.com:Shard-Labs/starknet-hardhat-example.git
+git clone -b decode-events-example --single-branch git@github.com:Shard-Labs/starknet-hardhat-example.git
 cd starknet-hardhat-example
 git log -n 1
 npm install

src/adapt.ts

@@ -379,6 +379,67 @@ export function adaptOutputUtil(
     }
     return adapted;
 }
+/**
+ * Adapts the string resulting from a Starknet CLI function call.
+ * This is done according to the actual output type specifed by the called function.
+ *
+ * @param rawResult the actual result in the form of an unparsed string
+ * @param datas array of starknet types in the expected event data
+ * @param abi the ABI of the contract whose function was called
+ */
+export function adaptEventUtil(
+    rawResult: string,
+    datas: starknet.Argument[],
+    abi: starknet.Abi
+): StringMap {
+    const splitStr = rawResult.split(" ");
+    const result: bigint[] = [];
+    for (const num of splitStr) {
+        const parsed = num[0] === "-" ? BigInt(num.substring(1)) * BigInt(-1) : BigInt(num);
+        result.push(parsed);
+    }
+    let resultIndex = 0;
+    let lastSpec: starknet.Argument = { type: null, name: null };
+    const adapted: StringMap = {};
+
+    for (const data of datas) {
+        const currentValue = result[resultIndex];
+        if (data.type === "felt") {
+            adapted[data.name] = currentValue;
+            resultIndex++;
+        } else if (data.type.endsWith("*")) {
+            // Assuming lastSpec refers to the array size argument; not checking its name - done during compilation
+            if (lastSpec.type !== "felt") {
+                const msg = `Array size argument (felt) must appear right before ${data.name} (${data.type}).`;
+                throw new HardhatPluginError(PLUGIN_NAME, msg);
+            }
+
+            // Remove * from the spec type
+            const dataArrayElementType = data.type.slice(0, -1);
+            const arrLength = parseInt(adapted[lastSpec.name]);
+
+            const structArray = [];
+
+            // Iterate over the struct array, starting at index, starting at `resultIndex`
+            for (let i = 0; i < arrLength; i++) {
+                // Generate a struct with each element of the array and push it to `structArray`
+                const ret = generateComplexOutput(result, resultIndex, dataArrayElementType, abi);
+                structArray.push(ret.generatedComplex);
+                // Next index is the proper raw index returned from generating the struct, which accounts for nested structs
+                resultIndex = ret.newRawIndex;
+            }
+            // New resultIndex is the raw index generated from the last struct
+            adapted[data.name] = structArray;
+        } else {
+            const ret = generateComplexOutput(result, resultIndex, data.type, abi);
+            adapted[data.name] = ret.generatedComplex;
+            resultIndex = ret.newRawIndex;
+        }
+
+        lastSpec = data;
+    }
+    return adapted;
+}
 
 /**
  * Uses the numbers in the `raw` array to generate a tuple/struct of the provided `type`.

src/devnet-utils.ts

@@ -44,7 +44,7 @@ export interface IncreaseTimeResponse {
 }
 
 export class DevnetUtils implements Devnet {
-    constructor(private hre: HardhatRuntimeEnvironment) { }
+    constructor(private hre: HardhatRuntimeEnvironment) {}
 
     private get endpoint() {
         return `${this.hre.config.starknet.networkUrl}`;
@@ -94,18 +94,17 @@ export class DevnetUtils implements Devnet {
                 `${this.endpoint}/increase_time`,
                 {
                     time: seconds
-                });
+                }
+            );
             return response.data;
         }, "Request failed. Make sure your network has the /increase_time endpoint");
     }
 
     public async setTime(seconds: number) {
         return this.withErrorHandler<SetTimeResponse>(async () => {
-            const response = await axios.post<SetTimeResponse>(
-                `${this.endpoint}/set_time`,
-                {
-                    time: seconds
-                });
+            const response = await axios.post<SetTimeResponse>(`${this.endpoint}/set_time`, {
+                time: seconds
+            });
             return response.data;
         }, "Request failed. Make sure your network has the /set_time endpoint");
     }

src/extend-utils.ts

@@ -86,7 +86,7 @@ export function shortStringToBigIntUtil(convertableString: string) {
     return BigInt("0x" + charArray.join(""));
 }
 
-export function bigIntToShortStringUtil(convertableBigInt: BigInt) {
+export function bigIntToShortStringUtil(convertableBigInt: bigint) {
     return Buffer.from(convertableBigInt.toString(16), "hex").toString();
 }
 

src/starknet-types.ts

@@ -28,7 +28,14 @@ export interface CairoFunction {
     outputs: Argument[];
 }
 
-export type AbiEntry = CairoFunction | Struct;
+export interface CairoEvent {
+    data: Argument[];
+    keys: Argument[];
+    name: string;
+    type: "event";
+}
+
+export type AbiEntry = CairoFunction | Struct | CairoEvent;
 
 export interface Abi {
     [name: string]: AbiEntry;

src/type-extensions.ts

@@ -167,14 +167,14 @@ declare module "hardhat/types/runtime" {
              * @param input the input short string
              * @returns the numeric equivalent of the input short string, wrapped in a `BigInt`
              */
-            shortStringToBigInt: (convertableString: string) => BigInt;
+            shortStringToBigInt: (convertableString: string) => bigint;
 
             /**
              * Converts a BigInt to a string. The opposite of {@link shortStringToBigInt}.
              * @param input the input BigInt
              * @returns a string which is the result of converting a BigInt's hex value to its ASCII equivalent
              */
-            bigIntToShortString: (convertableBigInt: BigInt) => string;
+            bigIntToShortString: (convertableBigInt: bigint) => string;
 
             /**
              * The selected starknet-network name.

src/types.ts

@@ -3,10 +3,10 @@ import * as starknet from "./starknet-types";
 import { HardhatPluginError } from "hardhat/plugins";
 import { PLUGIN_NAME, CHECK_STATUS_TIMEOUT, CHECK_STATUS_RECOVER_TIMEOUT } from "./constants";
 import { adaptLog, copyWithBigint } from "./utils";
-import { adaptInputUtil, adaptOutputUtil } from "./adapt";
+import { adaptInputUtil, adaptOutputUtil, adaptEventUtil } from "./adapt";
 import { StarknetWrapper } from "./starknet-wrappers";
 import { Wallet } from "hardhat/types";
-
+import { hash } from "starknet";
 /**
  * According to: https://starknet.io/docs/hello_starknet/intro.html#interact-with-the-contract
  * Not using an enum to avoid code duplication and reverse mapping.
@@ -700,4 +700,50 @@ export class StarknetContract {
         const func = <starknet.CairoFunction>this.abi[functionName];
         return adaptOutputUtil(rawResult, func.outputs, this.abi);
     }
+
+    /**
+     * Adapt `Event` to something more readable .
+     * @param eventNames  an array of the event's name that was emitted
+     * @param rawResult array of  the function output as as unparsed space separated string
+     * @returns structured output
+     */
+    adaptEvent(eventNames: string[], rawResult: string[]) {
+        const events: StringMap[] = [];
+        for (let i = 0; i < eventNames.length; i++) {
+            const func = <starknet.CairoEvent>this.abi[eventNames[i]];
+            const adapted = adaptEventUtil(rawResult[i], func.data, this.abi);
+            events.push(adapted);
+        }
+        return events;
+    }
+
+    /**
+     * decode Events to an array with all the arguments emmitted by the events.
+     * @param events array of unstructured events
+     * @returns array of the arguments emmitted by the events
+     */
+    async decodeEvents(events: starknet.Event[]): Promise<StringMap[]> {
+        const rawResult: string[] = [];
+        let rawResultIndex = 0;
+        for (const event of events) {
+            const result = event.data.map(BigInt).join(" ");
+            rawResult[rawResultIndex] = result;
+            rawResultIndex++;
+        }
+        const eventNames: string[] = [];
+        rawResultIndex = 0;
+        for (const functionName in this.abi) {
+            const func = this.abi[functionName];
+            if (func.type == "event") {
+                for (const event of events) {
+                    const result = hash.getSelectorFromName(func.name);
+                    if (event.keys[0] == result) {
+                        eventNames[rawResultIndex] = func.name;
+                        rawResultIndex++;
+                    }
+                }
+            }
+        }
+        return this.adaptEvent(eventNames, rawResult);
+    }
 }