starknet 3.2.0 → 3.5.0

package/dist/index.js

@@ -26,8 +26,8 @@ exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports
 /**
  * Main
  */
-__exportStar(require("./types"), exports);
 __exportStar(require("./contract"), exports);
+__exportStar(require("./types"), exports);
 __exportStar(require("./provider"), exports);
 __exportStar(require("./account"), exports);
 __exportStar(require("./signer"), exports);

package/dist/provider/default.d.ts

@@ -36,7 +36,9 @@ export declare class Provider implements ProviderInterface {
      * @param blockNumber
      * @returns the result of the function on the smart contract.
      */
-    callContract({ contractAddress, entrypoint, calldata }: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    callContract({ contractAddress, entrypoint, calldata }: Call, options?: {
+        blockIdentifier: BlockIdentifier;
+    }): Promise<CallContractResponse>;
     /**
      * Gets the block information
      *
@@ -113,13 +115,16 @@ export declare 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
+     * @param invocation
+     * @param _abi - (optional) signature to send along
      * @returns response from addTransaction
      */
     invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
+    estimateFee(invocation: Invocation): Promise<any>;
+    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
     waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }
 export {};

package/dist/provider/default.js

@@ -117,7 +117,7 @@ var Provider = /** @class */ (function () {
         return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
     };
     Provider.prototype.getFetchMethod = function (endpoint) {
-        var postMethodEndpoints = ['add_transaction', 'call_contract'];
+        var postMethodEndpoints = ['add_transaction', 'call_contract', 'estimate_fee'];
         return postMethodEndpoints.includes(endpoint) ? 'POST' : 'GET';
     };
     Provider.prototype.getQueryString = function (query) {
@@ -219,14 +219,12 @@ var Provider = /** @class */ (function () {
      * @param blockNumber
      * @returns the result of the function on the smart contract.
      */
-    Provider.prototype.callContract = function (_a, blockIdentifier) {
+    Provider.prototype.callContract = function (_a, options) {
         var contractAddress = _a.contractAddress, entrypoint = _a.entrypoint, _b = _a.calldata, calldata = _b === void 0 ? [] : _b;
-        if (blockIdentifier === void 0) { blockIdentifier = null; }
+        if (options === void 0) { options = { blockIdentifier: null }; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_c) {
-                return [2 /*return*/, this.fetchEndpoint('call_contract', {
-                        blockIdentifier: blockIdentifier,
-                    }, {
+                return [2 /*return*/, this.fetchEndpoint('call_contract', options, {
                         signature: [],
                         contract_address: contractAddress,
                         entry_point_selector: (0, hash_1.getSelectorFromName)(entrypoint),
@@ -371,10 +369,8 @@ 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
+     * @param invocation
+     * @param _abi - (optional) signature to send along
      * @returns response from addTransaction
      */
     Provider.prototype.invokeFunction = function (invocation, _abi) {
@@ -387,7 +383,18 @@ var Provider = /** @class */ (function () {
             signature: (0, number_1.bigNumberishArrayToDecimalStringArray)((_b = invocation.signature) !== null && _b !== void 0 ? _b : []),
         });
     };
-    Provider.prototype.waitForTx = function (txHash, retryInterval) {
+    Provider.prototype.estimateFee = function (invocation) {
+        var _a, _b;
+        return this.fetchEndpoint('estimate_fee', undefined, {
+            // TODO: change the TYPE of the call
+            type: 'INVOKE_FUNCTION',
+            contract_address: invocation.contractAddress,
+            entry_point_selector: (0, hash_1.getSelectorFromName)(invocation.entrypoint),
+            calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)((_a = invocation.calldata) !== null && _a !== void 0 ? _a : []),
+            signature: (0, number_1.bigNumberishArrayToDecimalStringArray)((_b = invocation.signature) !== null && _b !== void 0 ? _b : []),
+        });
+    };
+    Provider.prototype.waitForTransaction = function (txHash, retryInterval) {
         if (retryInterval === void 0) { retryInterval = 8000; }
         return __awaiter(this, void 0, void 0, function () {
             var onchain, res, message, error;
@@ -426,6 +433,17 @@ var Provider = /** @class */ (function () {
             });
         });
     };
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
+    Provider.prototype.waitForTx = function (txHash, retryInterval) {
+        if (retryInterval === void 0) { retryInterval = 8000; }
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.waitForTransaction(txHash, retryInterval)];
+            });
+        });
+    };
     return Provider;
 }());
 exports.Provider = Provider;

package/dist/provider/interface.d.ts

@@ -21,7 +21,9 @@ export declare abstract class ProviderInterface {
      * @param blockIdentifier block identifier
      * @returns the result of the function on the smart contract.
      */
-    abstract callContract(invokeTransaction: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
+    abstract callContract(invokeTransaction: Call, options: {
+        blockIdentifier: BlockIdentifier;
+    }): Promise<CallContractResponse>;
     /**
      * Gets the block information
      *
@@ -97,5 +99,9 @@ export declare abstract class ProviderInterface {
      * @returns response from addTransaction
      */
     abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
-    abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    /**
+     * @deprecated use `waitForTransaction` instead
+     */
+    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

package/dist/types/api.d.ts

@@ -57,6 +57,11 @@ export declare type Endpoints = {
         REQUEST: CallContractTransaction;
         RESPONSE: CallContractResponse;
     };
+    estimate_fee: {
+        QUERY: never;
+        REQUEST: Transaction;
+        RESPONSE: EstimateFeeResponse;
+    };
 };
 export declare type GetContractAddressesResponse = {
     Starknet: string;
@@ -143,6 +148,7 @@ export declare type TransactionReceipt = {
     l2_to_l1_messages: string[];
     events: string[];
 };
+export declare type EstimateFeeResponse = {};
 export declare type RawArgs = {
     [inputName: string]: string | string[] | {
         type: 'struct';

package/dist/types/contract.d.ts

@@ -0,0 +1,5 @@
+export declare type AsyncContractFunction<T = any> = (...args: Array<any>) => Promise<T>;
+export declare type ContractFunction = (...args: Array<any>) => any;
+export interface Result extends Array<any> {
+    [key: string]: any;
+}

package/dist/types/contract.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './lib';
 export * from './api';
 export * from './signer';
+export * from './contract';

package/dist/types/index.js

@@ -13,3 +13,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./lib"), exports);
 __exportStar(require("./api"), exports);
 __exportStar(require("./signer"), exports);
+__exportStar(require("./contract"), exports);

package/dist/types/lib.d.ts

@@ -33,7 +33,7 @@ export declare type FunctionAbi = {
     name: string;
     outputs: AbiEntry[];
     stateMutability?: 'view';
-    type: 'function';
+    type: 'function' | 'constructor';
 };
 export declare type StructAbi = {
     members: (AbiEntry & {
@@ -55,3 +55,13 @@ export declare type CompiledContract = {
 export declare type CompressedCompiledContract = Omit<CompiledContract, 'program'> & {
     program: CompressedProgram;
 };
+export declare type Struct = {
+    type: 'struct';
+    [k: string]: BigNumberish;
+};
+export declare type Args = {
+    [inputName: string]: BigNumberish | BigNumberish[] | ParsedStruct | ParsedStruct[];
+};
+export declare type ParsedStruct = {
+    [key: string]: BigNumberish | ParsedStruct;
+};

package/dist/utils/transaction.d.ts

@@ -1,5 +1,4 @@
-import { ParsedStruct } from '../contract';
-import { Call } from '../types';
+import { Call, ParsedStruct } from '../types';
 /**
  * Transforms a list of Calls, each with their own calldata, into
  * two arrays: one with the entrypoints, and one with the concatenated calldata.

package/index.d.ts

@@ -1,8 +1,8 @@
 /**
  * Main
  */
-export * from './types';
 export * from './contract';
+export * from './types';
 export * from './provider';
 export * from './account';
 export * from './signer';

package/index.js

@@ -58,8 +58,8 @@ exports.typedData =
 /**
  * Main
  */
-__exportStar(require('./types'), exports);
 __exportStar(require('./contract'), exports);
+__exportStar(require('./types'), exports);
 __exportStar(require('./provider'), exports);
 __exportStar(require('./account'), exports);
 __exportStar(require('./signer'), exports);

package/package.json

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

package/provider/default.d.ts

@@ -65,7 +65,9 @@ export declare class Provider implements ProviderInterface {
    */
   callContract(
     { contractAddress, entrypoint, calldata }: Call,
-    blockIdentifier?: BlockIdentifier
+    options?: {
+      blockIdentifier: BlockIdentifier;
+    }
   ): Promise<CallContractResponse>;
   /**
    * Gets the block information
@@ -150,13 +152,16 @@ export declare 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
+   * @param invocation
+   * @param _abi - (optional) signature to send along
    * @returns response from addTransaction
    */
   invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse>;
+  estimateFee(invocation: Invocation): Promise<any>;
+  waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+  /**
+   * @deprecated use `waitForTransaction` instead
+   */
   waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }
 export {};

package/provider/default.js

@@ -231,7 +231,7 @@ var Provider = /** @class */ (function () {
     return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
   };
   Provider.prototype.getFetchMethod = function (endpoint) {
-    var postMethodEndpoints = ['add_transaction', 'call_contract'];
+    var postMethodEndpoints = ['add_transaction', 'call_contract', 'estimate_fee'];
     return postMethodEndpoints.includes(endpoint) ? 'POST' : 'GET';
   };
   Provider.prototype.getQueryString = function (query) {
@@ -343,30 +343,24 @@ var Provider = /** @class */ (function () {
    * @param blockNumber
    * @returns the result of the function on the smart contract.
    */
-  Provider.prototype.callContract = function (_a, blockIdentifier) {
+  Provider.prototype.callContract = function (_a, options) {
     var contractAddress = _a.contractAddress,
       entrypoint = _a.entrypoint,
       _b = _a.calldata,
       calldata = _b === void 0 ? [] : _b;
-    if (blockIdentifier === void 0) {
-      blockIdentifier = null;
+    if (options === void 0) {
+      options = { blockIdentifier: null };
     }
     return __awaiter(this, void 0, void 0, function () {
       return __generator(this, function (_c) {
         return [
           2 /*return*/,
-          this.fetchEndpoint(
-            'call_contract',
-            {
-              blockIdentifier: blockIdentifier,
-            },
-            {
-              signature: [],
-              contract_address: contractAddress,
-              entry_point_selector: (0, hash_1.getSelectorFromName)(entrypoint),
-              calldata: calldata,
-            }
-          ),
+          this.fetchEndpoint('call_contract', options, {
+            signature: [],
+            contract_address: contractAddress,
+            entry_point_selector: (0, hash_1.getSelectorFromName)(entrypoint),
+            calldata: calldata,
+          }),
         ];
       });
     });
@@ -550,10 +544,8 @@ 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
+   * @param invocation
+   * @param _abi - (optional) signature to send along
    * @returns response from addTransaction
    */
   Provider.prototype.invokeFunction = function (invocation, _abi) {
@@ -570,7 +562,22 @@ var Provider = /** @class */ (function () {
       ),
     });
   };
-  Provider.prototype.waitForTx = function (txHash, retryInterval) {
+  Provider.prototype.estimateFee = function (invocation) {
+    var _a, _b;
+    return this.fetchEndpoint('estimate_fee', undefined, {
+      // TODO: change the TYPE of the call
+      type: 'INVOKE_FUNCTION',
+      contract_address: invocation.contractAddress,
+      entry_point_selector: (0, hash_1.getSelectorFromName)(invocation.entrypoint),
+      calldata: (0, number_1.bigNumberishArrayToDecimalStringArray)(
+        (_a = invocation.calldata) !== null && _a !== void 0 ? _a : []
+      ),
+      signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(
+        (_b = invocation.signature) !== null && _b !== void 0 ? _b : []
+      ),
+    });
+  };
+  Provider.prototype.waitForTransaction = function (txHash, retryInterval) {
     if (retryInterval === void 0) {
       retryInterval = 8000;
     }
@@ -615,6 +622,19 @@ var Provider = /** @class */ (function () {
       });
     });
   };
+  /**
+   * @deprecated use `waitForTransaction` instead
+   */
+  Provider.prototype.waitForTx = function (txHash, retryInterval) {
+    if (retryInterval === void 0) {
+      retryInterval = 8000;
+    }
+    return __awaiter(this, void 0, void 0, function () {
+      return __generator(this, function (_a) {
+        return [2 /*return*/, this.waitForTransaction(txHash, retryInterval)];
+      });
+    });
+  };
   return Provider;
 })();
 exports.Provider = Provider;

package/provider/interface.d.ts

@@ -35,7 +35,9 @@ export declare abstract class ProviderInterface {
    */
   abstract callContract(
     invokeTransaction: Call,
-    blockIdentifier?: BlockIdentifier
+    options: {
+      blockIdentifier: BlockIdentifier;
+    }
   ): Promise<CallContractResponse>;
   /**
    * Gets the block information
@@ -122,5 +124,9 @@ export declare abstract class ProviderInterface {
    * @returns response from addTransaction
    */
   abstract invokeFunction(invocation: Invocation): Promise<AddTransactionResponse>;
-  abstract waitForTx(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+  abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+  /**
+   * @deprecated use `waitForTransaction` instead
+   */
+  abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
 }

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/contract/contractFactory.ts

@@ -0,0 +1,78 @@
+import assert from 'minimalistic-assert';
+
+import { Account } from '../account';
+import { Provider, defaultProvider } from '../provider';
+import { Abi, CompiledContract, RawCalldata } from '../types';
+import { BigNumberish } from '../utils/number';
+import { Contract } from './default';
+
+export class ContractFactory {
+  abi: Abi;
+
+  compiledContract: CompiledContract;
+
+  providerOrAccount: Provider | Account;
+
+  constructor(
+    compiledContract: CompiledContract,
+    providerOrAccount: Provider | Account = defaultProvider,
+    abi: Abi = compiledContract.abi // abi can be different from the deployed contract ie for proxy contracts
+  ) {
+    this.abi = abi;
+    this.compiledContract = compiledContract;
+    this.providerOrAccount = providerOrAccount;
+  }
+
+  /**
+   * Deploys contract and returns new instance of the Contract
+   *
+   * @param constructorCalldata - Constructor Calldata
+   * @param addressSalt (optional) - Address Salt for deployment
+   * @returns deployed Contract
+   */
+  public async deploy(
+    constructorCalldata?: RawCalldata,
+    addressSalt?: BigNumberish
+  ): Promise<Contract> {
+    const { address, code, transaction_hash } = await this.providerOrAccount.deployContract({
+      contract: this.compiledContract,
+      constructorCalldata,
+      addressSalt,
+    });
+    assert(
+      code === 'TRANSACTION_RECEIVED' && Boolean(address),
+      'Deployment of the contract failed'
+    );
+
+    const contractInstance = new Contract(
+      this.compiledContract.abi,
+      address!,
+      this.providerOrAccount
+    );
+    contractInstance.deployTransactionHash = transaction_hash;
+
+    return contractInstance;
+  }
+
+  /**
+   * Attaches to new Provider or Account
+   *
+   * @param providerOrAccount - new Provider or Account to attach to
+   */
+  connect(providerOrAccount: Provider | Account): ContractFactory {
+    this.providerOrAccount = providerOrAccount;
+    return this;
+  }
+
+  /**
+   * Attaches current abi and provider or account to the new address
+   *
+   * @param address - Contract address
+   * @returns Contract
+   */
+  attach(address: string): Contract {
+    return new Contract(this.abi, address, this.providerOrAccount);
+  }
+
+  // ethers.js' getDeployTransaction cant be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
+}