starknet 5.15.1 → 5.16.0

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+# [5.16.0](https://github.com/0xs34n/starknet.js/compare/v5.15.1...v5.16.0) (2023-07-03)
+
+### Features
+
+- cairo1 version2 support ([e564033](https://github.com/0xs34n/starknet.js/commit/e564033273ac49e971bbf1db843fb3de236976c0))
+- extract parser from CallData and Cairo ([b7eba2a](https://github.com/0xs34n/starknet.js/commit/b7eba2a1eada3dddb4dc0575c16ac76a42a78678))
+- parsers ([cce9029](https://github.com/0xs34n/starknet.js/commit/cce90299e59e60090b568be14331378de3918924))
+
 ## [5.15.1](https://github.com/0xs34n/starknet.js/compare/v5.15.0...v5.15.1) (2023-06-29)
 
 ### Bug Fixes

package/dist/index.d.ts

@@ -3193,7 +3193,7 @@ declare function getVersionsByType(versionType?: 'fee' | 'transaction'): {
 };
 declare function computeHashOnElements(data: BigNumberish[]): string;
 declare function calculateTransactionHashCommon(txHashPrefix: TransactionHashPrefix, version: BigNumberish, contractAddress: BigNumberish, entryPointSelector: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, additionalData?: BigNumberish[]): string;
-declare function calculateDeployTransactionHash(contractAddress: BigNumberish, constructorCalldata: RawCalldata, version: BigNumberish, chainId: StarknetChainId): string;
+declare function calculateDeployTransactionHash(contractAddress: BigNumberish, constructorCalldata: RawCalldata, version: BigNumberish, chainId: StarknetChainId, constructorName?: string): string;
 declare function calculateDeclareTransactionHash(classHash: string, senderAddress: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish, compiledClassHash?: string): string;
 declare function calculateDeployAccountTransactionHash(contractAddress: BigNumberish, classHash: BigNumberish, constructorCalldata: RawCalldata, salt: BigNumberish, version: BigNumberish, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;
 declare function calculateTransactionHash(contractAddress: BigNumberish, version: BigNumberish, calldata: RawCalldata, maxFee: BigNumberish, chainId: StarknetChainId, nonce: BigNumberish): string;
@@ -3709,6 +3709,26 @@ declare function validateChecksumAddress(address: string): boolean;
 declare function isUrl(s?: string): boolean;
 declare function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string): string;
 
+declare abstract class AbiParserInterface {
+    /**
+     * Helper to calculate inputs length from abi
+     * @param abiMethod FunctionAbi
+     * @return number
+     */
+    abstract methodInputsLength(abiMethod: FunctionAbi): number;
+    /**
+     *
+     * @param name string
+     * @return FunctionAbi | undefined
+     */
+    abstract getMethod(name: string): FunctionAbi | undefined;
+    /**
+     * Return Abi in legacy format
+     * @return Abi
+     */
+    abstract getLegacyFormat(): Abi;
+}
+
 declare const isLen: (name: string) => boolean;
 declare const isTypeFelt: (type: string) => boolean;
 declare const isTypeArray: (type: string) => boolean;
@@ -3789,6 +3809,7 @@ declare namespace cairo {
 
 declare class CallData {
     abi: Abi;
+    parser: AbiParserInterface;
     protected readonly structs: AbiStructs;
     constructor(abi: Abi);
     /**
@@ -3834,12 +3855,6 @@ declare class CallData {
      * @returns Result - parsed and formatted response object
      */
     format(method: string, response: string[], format: object): Result;
-    /**
-     * Helper to calculate inputs from abi
-     * @param inputs AbiEntry
-     * @returns number
-     */
-    static abiInputsLength(inputs: AbiEntry[]): number;
     /**
      * Helper to extract structs from abi
      * @param abi Abi

package/dist/index.global.js

@@ -5727,6 +5727,9 @@ var starknet = (() => {
   function isCairo1Abi(abi) {
     const firstFunction = abi.find((entry) => entry.type === "function");
     if (!firstFunction) {
+      if (abi.find((it) => it.type === "interface")) {
+        return true;
+      }
       throw new Error(`Error in ABI. No function in ABI.`);
     }
     if (firstFunction.inputs.length) {
@@ -5828,6 +5831,92 @@ var starknet = (() => {
     }, {});
   }
 
+  // src/utils/calldata/parser/parser-0-1.1.0.ts
+  var AbiParser1 = class {
+    constructor(abi) {
+      this.abi = abi;
+    }
+    /**
+     * abi method inputs length without '_len' inputs
+     * cairo 0 reducer
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod) {
+      return abiMethod.inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
+    }
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name) {
+      return this.abi.find((it) => it.name === name);
+    }
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat() {
+      return this.abi;
+    }
+  };
+
+  // src/utils/calldata/parser/parser-2.0.0.ts
+  var AbiParser2 = class {
+    constructor(abi) {
+      this.abi = abi;
+    }
+    /**
+     * abi method inputs length
+     * @param abiMethod FunctionAbi
+     * @returns number
+     */
+    methodInputsLength(abiMethod) {
+      return abiMethod.inputs.length;
+    }
+    /**
+     * get method definition from abi
+     * @param name string
+     * @returns FunctionAbi | undefined
+     */
+    getMethod(name) {
+      const intf = this.abi.find((it) => it.type === "interface");
+      return intf.items.find((it) => it.name === name);
+    }
+    /**
+     * Get Abi in legacy format
+     * @returns Abi
+     */
+    getLegacyFormat() {
+      return this.abi.flatMap((e) => {
+        if (e.type === "interface") {
+          return e.items;
+        }
+        return e;
+      });
+    }
+  };
+
+  // src/utils/calldata/parser/index.ts
+  function createAbiParser(abi) {
+    const version = getAbiVersion(abi);
+    if (version === 0 || version === 1) {
+      return new AbiParser1(abi);
+    }
+    if (version === 2) {
+      return new AbiParser2(abi);
+    }
+    throw Error(`Unsupported ABI version ${version}`);
+  }
+  function getAbiVersion(abi) {
+    if (abi.find((it) => it.type === "interface"))
+      return 2;
+    if (isCairo1Abi(abi))
+      return 1;
+    return 0;
+  }
+
   // src/utils/calldata/tuple.ts
   function parseNamedTuple(namedTuple) {
     const name = namedTuple.substring(0, namedTuple.indexOf(":"));
@@ -6056,6 +6145,14 @@ var starknet = (() => {
       };
     });
   }
+  function parseUint256(element) {
+    if (typeof element === "object") {
+      const { low, high } = element;
+      return [felt(low), felt(high)];
+    }
+    const el_uint256 = uint256(element);
+    return [felt(el_uint256.low), felt(el_uint256.high)];
+  }
   function parseCalldataValue(element, type, structs) {
     if (element === void 0) {
       throw Error(`Missing parameter for type ${type}`);
@@ -6069,6 +6166,9 @@ var starknet = (() => {
       }, result);
     }
     if (structs[type] && structs[type].members.length) {
+      if (isTypeUint256(type)) {
+        return parseUint256(element);
+      }
       const { members } = structs[type];
       const subElement = element;
       return members.reduce((acc, it) => {
@@ -6083,12 +6183,7 @@ var starknet = (() => {
       }, []);
     }
     if (isTypeUint256(type)) {
-      if (typeof element === "object") {
-        const { low, high } = element;
-        return [felt(low), felt(high)];
-      }
-      const el_uint256 = uint256(element);
-      return [felt(el_uint256.low), felt(el_uint256.high)];
+      return parseUint256(element);
     }
     if (typeof element === "object") {
       throw Error(`Parameter ${element} do not align with abi parameter ${type}`);
@@ -6131,6 +6226,11 @@ var starknet = (() => {
     }
   }
   function parseResponseValue(responseIterator, element, structs) {
+    if (isTypeUint256(element.type)) {
+      const low = responseIterator.next().value;
+      const high = responseIterator.next().value;
+      return uint256ToBN({ low, high });
+    }
     if (element.type in structs && structs[element.type]) {
       return structs[element.type].members.reduce((acc, el) => {
         acc[el.name] = parseResponseValue(responseIterator, el, structs);
@@ -6257,6 +6357,10 @@ var starknet = (() => {
     );
   };
   var validateStruct = (parameter, input, structs) => {
+    if (input.type === "core::integer::u256" /* u256 */) {
+      validateUint(parameter, input);
+      return;
+    }
     assert(
       typeof parameter === "object" && !Array.isArray(parameter),
       `Validate: arg ${input.name} is cairo type struct (${input.type}), and should be defined as js object (not array)`
@@ -6346,8 +6450,9 @@ var starknet = (() => {
   // src/utils/calldata/index.ts
   var CallData = class {
     constructor(abi) {
-      this.abi = abi;
       this.structs = CallData.getAbiStruct(abi);
+      this.parser = createAbiParser(abi);
+      this.abi = this.parser.getLegacyFormat();
     }
     /**
      * Validate arguments passed to the method as corresponding to the ones in the abi
@@ -6369,9 +6474,9 @@ var starknet = (() => {
         );
       }
       const abiMethod = this.abi.find(
-        (abi) => type === "DEPLOY" /* DEPLOY */ ? abi.name === method && abi.type === method : abi.name === method && abi.type === "function"
+        (abi) => type === "DEPLOY" /* DEPLOY */ ? abi.name === method && abi.type === "constructor" : abi.name === method && abi.type === "function"
       );
-      const inputsLength = CallData.abiInputsLength(abiMethod.inputs);
+      const inputsLength = this.parser.methodInputsLength(abiMethod);
       if (args.length !== inputsLength) {
         throw Error(
           `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
@@ -6478,14 +6583,6 @@ var starknet = (() => {
       const parsed = this.parse(method, response);
       return formatter(parsed, format);
     }
-    /**
-     * Helper to calculate inputs from abi
-     * @param inputs AbiEntry
-     * @returns number
-     */
-    static abiInputsLength(inputs) {
-      return inputs.reduce((acc, input) => !isLen(input.name) ? acc + 1 : acc, 0);
-    }
     /**
      * Helper to extract structs from abi
      * @param abi Abi
@@ -7258,12 +7355,12 @@ var starknet = (() => {
     ];
     return computeHashOnElements2(dataToHash);
   }
-  function calculateDeployTransactionHash(contractAddress, constructorCalldata, version, chainId) {
+  function calculateDeployTransactionHash(contractAddress, constructorCalldata, version, chainId, constructorName = "constructor") {
     return calculateTransactionHashCommon(
       "0x6465706c6f79" /* DEPLOY */,
       version,
       contractAddress,
-      getSelectorFromName("constructor"),
+      getSelectorFromName(constructorName),
       constructorCalldata,
       0,
       chainId
@@ -14132,7 +14229,8 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
       this.providerOrAccount = providerOrAccount;
       this.callData = new CallData(abi);
       this.structs = CallData.getAbiStruct(abi);
-      this.abi = abi;
+      const parser = createAbiParser(abi);
+      this.abi = parser.getLegacyFormat();
       const options = { enumerable: true, value: {}, writable: false };
       Object.defineProperties(this, {
         functions: { enumerable: true, value: {}, writable: false },