starknet 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -1,3 +1,9 @@
+# [3.4.0](https://github.com/seanjameshan/starknet.js/compare/v3.3.0...v3.4.0) (2022-03-10)
+
+### Features
+
+- **account:** add legacy `addTransaction` method ([94f5d87](https://github.com/seanjameshan/starknet.js/commit/94f5d874c8fb5f6c6586d537b75b92f493a32676))
+
 # [3.3.0](https://github.com/seanjameshan/starknet.js/compare/v3.2.0...v3.3.0) (2022-03-08)
 
 ### Features

package/account/default.d.ts

@@ -6,6 +6,7 @@ import {
   InvocationsDetails,
   KeyPair,
   Signature,
+  Transaction,
 } from '../types';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
@@ -28,6 +29,11 @@ export declare class Account extends Provider implements AccountInterface {
     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
    *

package/account/default.js

@@ -189,10 +189,17 @@ 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');
@@ -295,6 +302,128 @@ var Account = /** @class */ (function (_super) {
       });
     });
   };
+  /**
+   * 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: '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(
+                    [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
+                  ),
+                  [calldata.length.toString()],
+                  false
+                ),
+                __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),
+              }),
+            ];
+        }
+      });
+    });
+  };
   /**
    * Sign an JSON object with the starknet private key and return the signature
    *

package/dist/account/default.d.ts

@@ -1,5 +1,5 @@
 import { Provider } from '../provider';
-import { Abi, AddTransactionResponse, Call, 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';
@@ -17,6 +17,11 @@ export declare class Account extends Provider implements AccountInterface {
      * @returns a confirmation of invoking a function on the starknet contract
      */
     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
      *

package/dist/account/default.js

@@ -75,10 +75,15 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     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");
@@ -157,6 +162,100 @@ var Account = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * 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: '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([
+                                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), [
+                                calldata.length.toString()
+                            ], false), __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),
+                            })];
+                }
+            });
+        });
+    };
     /**
      * Sign an JSON object with the starknet private key and return the signature
      *

package/dist/provider/default.d.ts

@@ -1,4 +1,4 @@
-import { Abi, AddTransactionResponse, Call, CallContractResponse, DeployContractPayload, Endpoints, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Invocation, Signature, TransactionReceipt } from '../types';
+import { Abi, AddTransactionResponse, Call, CallContractResponse, DeployContractPayload, Endpoints, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionResponse, GetTransactionStatusResponse, Invocation, TransactionReceipt } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier } from './utils';
@@ -118,17 +118,6 @@ export declare class Provider implements ProviderInterface {
      * @returns response from addTransaction
      */
     invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
-    /**
-     * Invokes a function on starknet
-     * @deprecated This method wont be supported as soon as fees are mandatory
-     *
-     * @param contractAddress - target contract address for invoke
-     * @param entrypointSelector - target entrypoint selector for
-     * @param calldata - (optional, default []) calldata
-     * @param signature - (optional) signature to send along
-     * @returns response from addTransaction
-     */
-    LEGACY_invokeFunction(contractAddress: string, entrypointSelector: string, calldata?: string[], signature?: Signature): Promise<AddTransactionResponse>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * @deprecated use `waitForTransaction` instead

package/dist/provider/default.js

@@ -385,25 +385,6 @@ var Provider = /** @class */ (function () {
             signature: (0, number_1.bigNumberishArrayToDecimalStringArray)((_b = invocation.signature) !== null && _b !== void 0 ? _b : []),
         });
     };
-    /**
-     * Invokes a function on starknet
-     * @deprecated This method wont be supported as soon as fees are mandatory
-     *
-     * @param contractAddress - target contract address for invoke
-     * @param entrypointSelector - target entrypoint selector for
-     * @param calldata - (optional, default []) calldata
-     * @param signature - (optional) signature to send along
-     * @returns response from addTransaction
-     */
-    Provider.prototype.LEGACY_invokeFunction = function (contractAddress, entrypointSelector, calldata, signature) {
-        return this.fetchEndpoint('add_transaction', undefined, {
-            type: 'INVOKE_FUNCTION',
-            contract_address: contractAddress,
-            entry_point_selector: entrypointSelector,
-            calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(calldata !== null && calldata !== void 0 ? calldata : []),
-            signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature !== null && signature !== void 0 ? signature : []),
-        });
-    };
     Provider.prototype.waitForTransaction = function (txHash, retryInterval) {
         if (retryInterval === void 0) { retryInterval = 8000; }
         return __awaiter(this, void 0, void 0, function () {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/provider/default.d.ts

@@ -11,7 +11,6 @@ import {
   GetTransactionResponse,
   GetTransactionStatusResponse,
   Invocation,
-  Signature,
   TransactionReceipt,
 } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -156,22 +155,6 @@ export declare class Provider implements ProviderInterface {
    * @returns response from addTransaction
    */
   invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
-  /**
-   * Invokes a function on starknet
-   * @deprecated This method wont be supported as soon as fees are mandatory
-   *
-   * @param contractAddress - target contract address for invoke
-   * @param entrypointSelector - target entrypoint selector for
-   * @param calldata - (optional, default []) calldata
-   * @param signature - (optional) signature to send along
-   * @returns response from addTransaction
-   */
-  LEGACY_invokeFunction(
-    contractAddress: string,
-    entrypointSelector: string,
-    calldata?: string[],
-    signature?: Signature
-  ): Promise<AddTransactionResponse>;
   waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
   /**
    * @deprecated use `waitForTransaction` instead

package/provider/default.js

@@ -568,34 +568,6 @@ var Provider = /** @class */ (function () {
       ),
     });
   };
-  /**
-   * Invokes a function on starknet
-   * @deprecated This method wont be supported as soon as fees are mandatory
-   *
-   * @param contractAddress - target contract address for invoke
-   * @param entrypointSelector - target entrypoint selector for
-   * @param calldata - (optional, default []) calldata
-   * @param signature - (optional) signature to send along
-   * @returns response from addTransaction
-   */
-  Provider.prototype.LEGACY_invokeFunction = function (
-    contractAddress,
-    entrypointSelector,
-    calldata,
-    signature
-  ) {
-    return this.fetchEndpoint('add_transaction', undefined, {
-      type: 'INVOKE_FUNCTION',
-      contract_address: contractAddress,
-      entry_point_selector: entrypointSelector,
-      calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(
-        calldata !== null && calldata !== void 0 ? calldata : []
-      ),
-      signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(
-        signature !== null && signature !== void 0 ? signature : []
-      ),
-    });
-  };
   Provider.prototype.waitForTransaction = function (txHash, retryInterval) {
     if (retryInterval === void 0) {
       retryInterval = 8000;

package/src/account/default.ts

@@ -1,3 +1,5 @@
+import assert from 'minimalistic-assert';
+
 import { Provider } from '../provider';
 import { Signer, SignerInterface } from '../signer';
 import {
@@ -5,10 +7,18 @@ import {
   AddTransactionResponse,
   Call,
   InvocationsDetails,
+  InvokeFunctionTransaction,
   KeyPair,
   Signature,
+  Transaction,
 } from '../types';
-import { getSelectorFromName } from '../utils/hash';
+import { sign } from '../utils/ellipticCurve';
+import {
+  computeHashOnElements,
+  getSelectorFromName,
+  transactionPrefix,
+  transactionVersion,
+} from '../utils/hash';
 import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
 import { compileCalldata } from '../utils/stark';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
@@ -68,6 +78,104 @@ export class Account extends Provider implements AccountInterface {
     });
   }
 
+  /**
+   * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
+   * @deprecated to remove ASAP
+   */
+  public async LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse> {
+    if (transaction.type === 'DEPLOY') throw new Error('No DEPLOYS');
+
+    assert(
+      !transaction.signature,
+      "Adding signatures to a signer transaction currently isn't supported"
+    );
+
+    let nonceBn;
+    if (transaction.nonce) {
+      nonceBn = toBN(transaction.nonce);
+    } else {
+      const { result } = await this.callContract({
+        contractAddress: this.address,
+        entrypoint: 'get_nonce',
+      });
+      nonceBn = toBN(result[0]);
+    }
+
+    function hashMulticall(
+      account: string,
+      transactions: InvokeFunctionTransaction[],
+      nonce: string,
+      maxFee: string
+    ) {
+      const hashArray = transactions
+        .map(({ contract_address, entry_point_selector, calldata }) => [
+          contract_address,
+          entry_point_selector,
+          computeHashOnElements(calldata || []),
+        ])
+        .map(bigNumberishArrayToDecimalStringArray)
+        .map(computeHashOnElements);
+
+      return computeHashOnElements([
+        transactionPrefix,
+        account,
+        computeHashOnElements(hashArray),
+        nonce,
+        maxFee,
+        transactionVersion,
+      ]);
+    }
+    const msgHash = hashMulticall(this.address, [transaction], nonceBn.toString(), '0');
+    if (!('keyPair' in this.signer)) {
+      throw new Error('No keyPair');
+    }
+    const signature = sign((this.signer as any).keyPair, msgHash);
+
+    const transformCallsToMulticallArrays = (calls: InvokeFunctionTransaction[]) => {
+      const callArray: any[] = [];
+      const calldata: BigNumberish[] = [];
+      calls.forEach((call) => {
+        const data = call.calldata || [];
+        callArray.push({
+          to: toBN(call.contract_address).toString(10),
+          selector: toBN(call.entry_point_selector).toString(10),
+          data_offset: calldata.length.toString(),
+          data_len: data.length.toString(),
+        });
+        calldata.push(...data);
+      });
+      return {
+        callArray,
+        calldata: bigNumberishArrayToDecimalStringArray(calldata),
+      };
+    };
+
+    const fromCallsToExecuteCalldata2 = (calls: InvokeFunctionTransaction[]): string[] => {
+      const { callArray, calldata } = transformCallsToMulticallArrays(calls);
+      return [
+        callArray.length.toString(),
+        ...callArray
+          .map(
+            ({ to, selector, data_offset, data_len }) =>
+              [to, selector, data_offset, data_len] as string[]
+          )
+          .flat(),
+        calldata.length.toString(),
+        ...calldata,
+      ];
+    };
+
+    const calldata = [...fromCallsToExecuteCalldata2([transaction]), nonceBn.toString()];
+
+    return this.fetchEndpoint('add_transaction', undefined, {
+      type: 'INVOKE_FUNCTION',
+      contract_address: this.address,
+      entry_point_selector: getSelectorFromName('__execute__'),
+      calldata,
+      signature: bigNumberishArrayToDecimalStringArray(signature),
+    });
+  }
+
   /**
    * Sign an JSON object with the starknet private key and return the signature
    *

package/src/provider/default.ts

@@ -15,7 +15,6 @@ import {
   GetTransactionResponse,
   GetTransactionStatusResponse,
   Invocation,
-  Signature,
   TransactionReceipt,
 } from '../types';
 import { getSelectorFromName } from '../utils/hash';
@@ -332,31 +331,6 @@ export class Provider implements ProviderInterface {
     });
   }
 
-  /**
-   * Invokes a function on starknet
-   * @deprecated This method wont be supported as soon as fees are mandatory
-   *
-   * @param contractAddress - target contract address for invoke
-   * @param entrypointSelector - target entrypoint selector for
-   * @param calldata - (optional, default []) calldata
-   * @param signature - (optional) signature to send along
-   * @returns response from addTransaction
-   */
-  public LEGACY_invokeFunction(
-    contractAddress: string,
-    entrypointSelector: string,
-    calldata?: string[],
-    signature?: Signature
-  ): Promise<AddTransactionResponse> {
-    return this.fetchEndpoint('add_transaction', undefined, {
-      type: 'INVOKE_FUNCTION',
-      contract_address: contractAddress,
-      entry_point_selector: entrypointSelector,
-      calldata: bigNumberishArrayToDecimalStringArray(calldata ?? []),
-      signature: bigNumberishArrayToDecimalStringArray(signature ?? []),
-    });
-  }
-
   public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
     let onchain = false;
     await wait(retryInterval);