starknet 3.0.0 → 3.3.0

package/__tests__/utils/ellipticalCurve.test.ts

@@ -1,6 +1,6 @@
 import { ec, getKeyPair, getStarkKey, sign, verify } from '../../src/utils/ellipticCurve';
 import { removeHexPrefix } from '../../src/utils/encode';
-import { hashCalldata, hashMessage, pedersen } from '../../src/utils/hash';
+import { computeHashOnElements, hashMulticall, pedersen } from '../../src/utils/hash';
 import { toBN, toHex } from '../../src/utils/number';
 
 test('getKeyPair()', () => {
@@ -17,35 +17,42 @@ test('pedersen()', () => {
   expect(own).toMatchSnapshot();
 });
 
-test('hashCalldata()', () => {
+test('computeHashOnElements()', () => {
   const array = ['1', '2', '3', '4'];
-  expect(hashCalldata(array)).toBe(
+  expect(computeHashOnElements(array)).toBe(
     '0x66bd4335902683054d08a0572747ea78ebd9e531536fb43125424ca9f902084'
   );
   expect(array).toStrictEqual(['1', '2', '3', '4']);
 
-  expect(hashCalldata(['1', '2'])).toBe(
+  expect(computeHashOnElements(['1', '2'])).toBe(
     '0x501a3a8e6cd4f5241c639c74052aaa34557aafa84dd4ba983d6443c590ab7df'
   );
 });
 
 test('hashMessage()', () => {
   const privateKey = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
-  const hashMsg = hashMessage(
-    '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745',
-    '5',
-    '6',
-    ['1', '2'],
-    '2'
+  const account = '2007067565103695475819120104515800035851923905855118399071773059478896040938';
+  const transactions = [
+    {
+      contractAddress:
+        '3290661298119599979891444342541795905081168856323302956721669397616389152866',
+      entrypoint: 'set_number',
+      calldata: ['47'],
+    },
+  ];
+  const nonce = '3';
+  const maxFee = '0';
+  const hashMsg = hashMulticall(account, transactions, nonce, maxFee);
+  expect(hashMsg).toBe(
+    toHex(toBN('1608351043472325350463069815257733118091727529101532499046754244230898025592'))
   );
-  expect(hashMsg).toBe('0x7f15c38ea577a26f4f553282fcfe4f1feeb8ecfaad8f221ae41abf8224cbddd');
   const keyPair = getKeyPair(privateKey);
   const [r, s] = sign(keyPair, removeHexPrefix(hashMsg));
   expect(r.toString()).toStrictEqual(
-    toBN('2458502865976494910213617956670505342647705497324144349552978333078363662855').toString()
+    toBN('1079537730825246752292590270213864261175133133352510235773017189606850691611').toString()
   );
   expect(s.toString()).toStrictEqual(
-    toBN('3439514492576562277095748549117516048613512930236865921315982886313695689433').toString()
+    toBN('2904560423220491364719171767721067837294296476624248675613584621502231297000').toString()
   );
 });
 

package/__tests__/utils/utils.test.ts

@@ -44,17 +44,17 @@ describe('makeAddress()', () => {
 });
 describe('getSelectorFromName()', () => {
   test('hash works for value="test"', () => {
-    expect(stark.getSelectorFromName('test')).toBe(
+    expect(hash.getSelectorFromName('test')).toBe(
       '0x22ff5f21f0b81b113e63f7db6da94fedef11b2119b4088b89664fb9a3cb658'
     );
   });
   test('hash works for value="initialize"', () => {
-    expect(stark.getSelectorFromName('initialize')).toBe(
+    expect(hash.getSelectorFromName('initialize')).toBe(
       '0x79dc0da7c54b95f10aa182ad0a46400db63156920adb65eca2654c0945a463'
     );
   });
   test('hash works for value="mint"', () => {
-    expect(stark.getSelectorFromName('mint')).toBe(
+    expect(hash.getSelectorFromName('mint')).toBe(
       '0x2f0b3c5710379609eb5495f1ecd348cb28167711b73609fe565a72734550354'
     );
   });

package/account/default.d.ts

@@ -2,7 +2,7 @@ import { Provider } from '../provider';
 import {
   Abi,
   AddTransactionResponse,
-  ExecuteInvocation,
+  Call,
   InvocationsDetails,
   KeyPair,
   Signature,
@@ -24,8 +24,8 @@ export declare class Account extends Provider implements AccountInterface {
    * @returns a confirmation of invoking a function on the starknet contract
    */
   execute(
-    transactions: ExecuteInvocation | ExecuteInvocation[],
-    abis?: Abi[],
+    calls: Call | Call[],
+    abis?: Abi[] | undefined,
     transactionsDetail?: InvocationsDetails
   ): Promise<AddTransactionResponse>;
   /**
@@ -47,7 +47,7 @@ export declare class Account extends Provider implements AccountInterface {
   /**
    * Verify a signature of a JSON object
    *
-   * @param json - JSON object to be verified
+   * @param hash - JSON object to be verified
    * @param signature - signature of the JSON object
    * @returns true if the signature is valid, false otherwise
    * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature

package/account/default.js

@@ -24,20 +24,6 @@ var __extends =
       d.prototype = b === null ? Object.create(b) : ((__.prototype = b.prototype), new __());
     };
   })();
-var __assign =
-  (this && this.__assign) ||
-  function () {
-    __assign =
-      Object.assign ||
-      function (t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-        }
-        return t;
-      };
-    return __assign.apply(this, arguments);
-  };
 var __awaiter =
   (this && this.__awaiter) ||
   function (thisArg, _arguments, P, generator) {
@@ -169,19 +155,6 @@ var __generator =
       return { value: op[0] ? op[1] : void 0, done: true };
     }
   };
-var __rest =
-  (this && this.__rest) ||
-  function (s, e) {
-    var t = {};
-    for (var p in s)
-      if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === 'function')
-      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-        if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-          t[p[i]] = s[p[i]];
-      }
-    return t;
-  };
 var __read =
   (this && this.__read) ||
   function (o, n) {
@@ -218,11 +191,12 @@ var __spreadArray =
   };
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.Account = void 0;
-var contract_1 = require('../contract');
 var provider_1 = require('../provider');
 var signer_1 = require('../signer');
+var hash_1 = require('../utils/hash');
 var number_1 = require('../utils/number');
 var stark_1 = require('../utils/stark');
+var transaction_1 = require('../utils/transaction');
 var typedData_1 = require('../utils/typedData');
 var Account = /** @class */ (function (_super) {
   __extends(Account, _super);
@@ -260,84 +234,61 @@ var Account = /** @class */ (function (_super) {
    * @param transaction - transaction to be invoked
    * @returns a confirmation of invoking a function on the starknet contract
    */
-  Account.prototype.execute = function (transactions, abis, transactionsDetail) {
+  Account.prototype.execute = function (calls, abis, transactionsDetail) {
+    var _a, _b;
     if (abis === void 0) {
-      abis = [];
+      abis = undefined;
     }
     if (transactionsDetail === void 0) {
       transactionsDetail = {};
     }
     return __awaiter(this, void 0, void 0, function () {
-      var _a,
-        contractAddress,
-        _b,
-        calldata,
-        entrypoint,
-        invocation,
-        nonce,
-        nonceBn,
-        _c,
-        _d,
-        calldataDecimal,
-        signature,
-        entrypointSelector;
-      return __generator(this, function (_e) {
-        switch (_e.label) {
+      var transactions, signerDetails, _c, _d, signature, calldata;
+      var _e;
+      return __generator(this, function (_f) {
+        switch (_f.label) {
           case 0:
-            if (Array.isArray(transactions) && transactions.length !== 1) {
-              throw new Error('Only one transaction at a time is currently supported');
-            }
-            (_a = Array.isArray(transactions) ? transactions[0] : transactions),
-              (contractAddress = _a.contractAddress),
-              (_b = _a.calldata),
-              (calldata = _b === void 0 ? [] : _b),
-              (entrypoint = _a.entrypoint),
-              (invocation = __rest(_a, ['contractAddress', 'calldata', 'entrypoint']));
-            nonce = transactionsDetail.nonce;
+            transactions = Array.isArray(calls) ? calls : [calls];
+            _e = {
+              walletAddress: this.address,
+            };
             _c = number_1.toBN;
-            if (!(nonce !== null && nonce !== void 0)) return [3 /*break*/, 1];
-            _d = nonce;
+            if (!((_a = transactionsDetail.nonce) !== null && _a !== void 0))
+              return [3 /*break*/, 1];
+            _d = _a;
             return [3 /*break*/, 3];
           case 1:
             return [4 /*yield*/, this.getNonce()];
           case 2:
-            _d = _e.sent();
-            _e.label = 3;
+            _d = _f.sent();
+            _f.label = 3;
           case 3:
-            nonceBn = _c.apply(void 0, [_d]);
-            calldataDecimal = (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata);
-            return [
-              4 /*yield*/,
-              this.signer.signTransaction(
-                [
-                  __assign(__assign({}, invocation), {
-                    contractAddress: contractAddress,
-                    calldata: calldataDecimal,
-                    entrypoint: entrypoint,
-                  }),
-                ],
-                { walletAddress: this.address, nonce: nonceBn },
-                abis
-              ),
-            ];
+            signerDetails =
+              ((_e.nonce = _c.apply(void 0, [_d])),
+              (_e.maxFee = (0, number_1.toBN)(
+                (_b = transactionsDetail.maxFee) !== null && _b !== void 0 ? _b : '0'
+              )),
+              _e);
+            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
           case 4:
-            signature = _e.sent();
-            entrypointSelector = (0, stark_1.getSelectorFromName)(entrypoint);
+            signature = _f.sent();
+            calldata = __spreadArray(
+              __spreadArray(
+                [],
+                __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)),
+                false
+              ),
+              [signerDetails.nonce.toString()],
+              false
+            );
             return [
               2 /*return*/,
-              _super.prototype.invokeFunction.call(this, {
-                contractAddress: this.address,
-                entrypoint: 'execute',
-                calldata: __spreadArray(
-                  __spreadArray(
-                    [contractAddress, entrypointSelector, calldataDecimal.length.toString()],
-                    __read(calldataDecimal),
-                    false
-                  ),
-                  [nonceBn.toString()],
-                  false
-                ),
-                signature: signature,
+              this.fetchEndpoint('add_transaction', undefined, {
+                type: 'INVOKE_FUNCTION',
+                contract_address: this.address,
+                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
+                calldata: calldata,
+                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
               }),
             ];
         }
@@ -375,7 +326,7 @@ var Account = /** @class */ (function (_super) {
   /**
    * Verify a signature of a JSON object
    *
-   * @param json - JSON object to be verified
+   * @param hash - JSON object to be verified
    * @param signature - signature of the JSON object
    * @returns true if the signature is valid, false otherwise
    * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
@@ -392,7 +343,7 @@ var Account = /** @class */ (function (_super) {
               this.callContract({
                 contractAddress: this.address,
                 entrypoint: 'is_valid_signature',
-                calldata: (0, contract_1.compileCalldata)({
+                calldata: (0, stark_1.compileCalldata)({
                   hash: (0, number_1.toBN)(hash).toString(),
                   signature: signature.map(function (x) {
                     return (0, number_1.toBN)(x).toString();

package/account/interface.d.ts

@@ -2,8 +2,8 @@ import { ProviderInterface } from '../provider';
 import {
   Abi,
   AddTransactionResponse,
+  Call,
   DeployContractPayload,
-  ExecuteInvocation,
   InvocationsDetails,
   Signature,
 } from '../types';
@@ -38,7 +38,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
    * @returns response from addTransaction
    */
   abstract execute(
-    transactions: ExecuteInvocation | ExecuteInvocation[],
+    transactions: Call | Call[],
     abis?: Abi[],
     transactionsDetail?: InvocationsDetails
   ): Promise<AddTransactionResponse>;

package/contract.d.ts

@@ -1,17 +1,17 @@
 import { Provider } from './provider';
 import { BlockIdentifier } from './provider/utils';
-import { Abi, RawCalldata, Signature, StructAbi } from './types';
+import { Abi, Signature, StructAbi } from './types';
 import { BigNumberish } from './utils/number';
+export declare type Struct = {
+  type: 'struct';
+  [k: string]: BigNumberish;
+};
+export declare type ParsedStruct = {
+  [key: string]: BigNumberish | ParsedStruct;
+};
 export declare type Args = {
-  [inputName: string]:
-    | string
-    | string[]
-    | {
-        type: 'struct';
-        [k: string]: BigNumberish;
-      };
+  [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
 };
-export declare function compileCalldata(args: Args): RawCalldata;
 export declare class Contract {
   connectedTo: string | null;
   abi: Abi;
@@ -26,9 +26,68 @@ export declare class Contract {
    * @param address (optional) - address to connect to
    */
   constructor(abi: Abi, address?: string | null, provider?: Provider);
+  /**
+   * Saves the address of the contract deployed on network that will be used for interaction
+   *
+   * @param address - address of the contract
+   * @returns Contract
+   */
   connect(address: string): Contract;
+  /**
+   * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
+   *
+   * @param type - type of the method
+   * @param method  - name of the method
+   * @param args - arguments that are passed to the method
+   */
   private validateMethodAndArgs;
+  /**
+   * Deep parse of the object that has been passed to the method
+   *
+   * @param element - element that needs to be parsed
+   * @param type  - name of the method
+   * @return {string | string[]} - parsed arguments in format that contract is expecting
+   */
+  private parseCalldataObject;
+  /**
+   * Parse of the response elements that are converted to Object (Struct) by using the abi
+   *
+   * @param responseIterator - iterator of the response
+   * @param type - type of the struct
+   * @return {BigNumberish | ParsedStruct} - parsed arguments in format that contract is expecting
+   */
+  private parseResponseStruct;
+  /**
+   * Parse one field of the calldata by using input field from the abi for that method
+   *
+   * @param args - value of the field
+   * @param input  - input(field) information from the abi that will be used to parse the data
+   * @return {string | string[]} - parsed arguments in format that contract is expecting
+   */
+  private parsCalldataField;
+  /**
+   * Parse the calldata by using input fields from the abi for that method
+   *
+   * @param args - arguments passed the the method
+   * @param inputs  - list of inputs(fields) that are in the abi
+   * @return {Calldata} - parsed arguments in format that contract is expecting
+   */
+  private compileCalldata;
+  /**
+   * Parse elements of the response and structuring them into one field by using output property from the abi for that method
+   *
+   * @param responseIterator - iterator of the response
+   * @param output  - output(field) information from the abi that will be used to parse the data
+   * @return - parsed response corresponding to the abi structure of the field
+   */
   private parseResponseField;
+  /**
+   * Parse elements of the response array and structuring them into response object
+   *
+   * @param method - method name
+   * @param response  - response from the method
+   * @return - parsed response corresponding to the abi
+   */
   private parseResponse;
   invoke(
     method: string,