starknet 3.1.0 → 3.4.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,10 +2,11 @@ import { Provider } from '../provider';
 import {
   Abi,
   AddTransactionResponse,
-  ExecuteInvocation,
+  Call,
   InvocationsDetails,
   KeyPair,
   Signature,
+  Transaction,
 } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
@@ -24,10 +25,15 @@ 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>;
+  /**
+   * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
+   * @deprecated to remove ASAP
+   */
+  LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
   /**
    * Sign an JSON object with the starknet private key and return the signature
    *
@@ -47,7 +53,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) {
@@ -216,12 +189,21 @@ var __spreadArray =
       }
     return to.concat(ar || Array.prototype.slice.call(from));
   };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
 Object.defineProperty(exports, '__esModule', { value: true });
 exports.Account = void 0;
+var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
 var provider_1 = require('../provider');
 var signer_1 = require('../signer');
+var ellipticCurve_1 = require('../utils/ellipticCurve');
+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);
@@ -259,84 +241,183 @@ 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, {
+              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),
+              }),
+            ];
+        }
+      });
+    });
+  };
+  /**
+   * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
+   * @deprecated to remove ASAP
+   */
+  Account.prototype.LEGACY_addTransaction = function (transaction) {
+    return __awaiter(this, void 0, void 0, function () {
+      function hashMulticall(account, transactions, nonce, maxFee) {
+        var hashArray = transactions
+          .map(function (_a) {
+            var contract_address = _a.contract_address,
+              entry_point_selector = _a.entry_point_selector,
+              calldata = _a.calldata;
+            return [
+              contract_address,
+              entry_point_selector,
+              (0, hash_1.computeHashOnElements)(calldata || []),
+            ];
+          })
+          .map(number_1.bigNumberishArrayToDecimalStringArray)
+          .map(hash_1.computeHashOnElements);
+        return (0,
+        hash_1.computeHashOnElements)([hash_1.transactionPrefix, account, (0, hash_1.computeHashOnElements)(hashArray), nonce, maxFee, hash_1.transactionVersion]);
+      }
+      var nonceBn,
+        result,
+        msgHash,
+        signature,
+        transformCallsToMulticallArrays,
+        fromCallsToExecuteCalldata2,
+        calldata;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            if (transaction.type === 'DEPLOY') throw new Error('No DEPLOYS');
+            (0,
+            minimalistic_assert_1.default)(!transaction.signature, "Adding signatures to a signer transaction currently isn't supported");
+            if (!transaction.nonce) return [3 /*break*/, 1];
+            nonceBn = (0, number_1.toBN)(transaction.nonce);
+            return [3 /*break*/, 3];
+          case 1:
+            return [
+              4 /*yield*/,
+              this.callContract({
                 contractAddress: this.address,
-                entrypoint: 'execute',
-                calldata: __spreadArray(
+                entrypoint: 'get_nonce',
+              }),
+            ];
+          case 2:
+            result = _a.sent().result;
+            nonceBn = (0, number_1.toBN)(result[0]);
+            _a.label = 3;
+          case 3:
+            msgHash = hashMulticall(this.address, [transaction], nonceBn.toString(), '0');
+            if (!('keyPair' in this.signer)) {
+              throw new Error('No keyPair');
+            }
+            signature = (0, ellipticCurve_1.sign)(this.signer.keyPair, msgHash);
+            transformCallsToMulticallArrays = function (calls) {
+              var callArray = [];
+              var calldata = [];
+              calls.forEach(function (call) {
+                var data = call.calldata || [];
+                callArray.push({
+                  to: (0, number_1.toBN)(call.contract_address).toString(10),
+                  selector: (0, number_1.toBN)(call.entry_point_selector).toString(10),
+                  data_offset: calldata.length.toString(),
+                  data_len: data.length.toString(),
+                });
+                calldata.push.apply(calldata, __spreadArray([], __read(data), false));
+              });
+              return {
+                callArray: callArray,
+                calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata),
+              };
+            };
+            fromCallsToExecuteCalldata2 = function (calls) {
+              var _a = transformCallsToMulticallArrays(calls),
+                callArray = _a.callArray,
+                calldata = _a.calldata;
+              return __spreadArray(
+                __spreadArray(
                   __spreadArray(
-                    [contractAddress, entrypointSelector, calldataDecimal.length.toString()],
-                    __read(calldataDecimal),
+                    [callArray.length.toString()],
+                    __read(
+                      callArray
+                        .map(function (_a) {
+                          var to = _a.to,
+                            selector = _a.selector,
+                            data_offset = _a.data_offset,
+                            data_len = _a.data_len;
+                          return [to, selector, data_offset, data_len];
+                        })
+                        .flat()
+                    ),
                     false
                   ),
-                  [nonceBn.toString()],
+                  [calldata.length.toString()],
                   false
                 ),
-                signature: signature,
+                __read(calldata),
+                false
+              );
+            };
+            calldata = __spreadArray(
+              __spreadArray([], __read(fromCallsToExecuteCalldata2([transaction])), false),
+              [nonceBn.toString()],
+              false
+            );
+            return [
+              2 /*return*/,
+              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),
               }),
             ];
         }
@@ -374,7 +455,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

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/dist/account/default.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from '../provider';
-import { Abi, AddTransactionResponse, ExecuteInvocation, InvocationsDetails, KeyPair, Signature } from '../types';
+import { Abi, AddTransactionResponse, Call, InvocationsDetails, KeyPair, Signature, Transaction } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -16,7 +16,12 @@ export declare class Account extends Provider implements AccountInterface {
      * @param transaction - transaction to be invoked
      * @returns a confirmation of invoking a function on the starknet contract
      */
-    execute(transactions: ExecuteInvocation | ExecuteInvocation[], abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
+    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<AddTransactionResponse>;
+    /**
+     * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
+     * @deprecated to remove ASAP
+     */
+    LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
     /**
      * Sign an JSON object with the starknet private key and return the signature
      *
@@ -36,7 +41,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