starknet 3.4.0 → 3.6.0

package/account/default.js

@@ -233,6 +233,46 @@ var Account = /** @class */ (function (_super) {
       });
     });
   };
+  Account.prototype.estimateFee = function (calls) {
+    return __awaiter(this, void 0, void 0, function () {
+      var transactions, nonce, signerDetails, signature, calldata;
+      return __generator(this, function (_a) {
+        switch (_a.label) {
+          case 0:
+            transactions = Array.isArray(calls) ? calls : [calls];
+            return [4 /*yield*/, this.getNonce()];
+          case 1:
+            nonce = _a.sent();
+            signerDetails = {
+              walletAddress: this.address,
+              nonce: (0, number_1.toBN)(nonce),
+              maxFee: (0, number_1.toBN)('0'),
+            };
+            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
+          case 2:
+            signature = _a.sent();
+            calldata = __spreadArray(
+              __spreadArray(
+                [],
+                __read((0, transaction_1.fromCallsToExecuteCalldata)(transactions)),
+                false
+              ),
+              [signerDetails.nonce.toString()],
+              false
+            );
+            return [
+              2 /*return*/,
+              this.fetchEndpoint('estimate_fee', undefined, {
+                contract_address: this.address,
+                entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
+                calldata: calldata,
+                signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
+              }),
+            ];
+        }
+      });
+    });
+  };
   /**
    * Invoke execute function in account contract
    *
@@ -250,15 +290,11 @@ var Account = /** @class */ (function (_super) {
       transactionsDetail = {};
     }
     return __awaiter(this, void 0, void 0, function () {
-      var transactions, signerDetails, _c, _d, signature, calldata;
-      var _e;
+      var transactions, nonce, _c, _d, maxFee, _e, signerDetails, signature, calldata;
       return __generator(this, function (_f) {
         switch (_f.label) {
           case 0:
             transactions = Array.isArray(calls) ? calls : [calls];
-            _e = {
-              walletAddress: this.address,
-            };
             _c = number_1.toBN;
             if (!((_a = transactionsDetail.nonce) !== null && _a !== void 0))
               return [3 /*break*/, 1];
@@ -270,14 +306,25 @@ var Account = /** @class */ (function (_super) {
             _d = _f.sent();
             _f.label = 3;
           case 3:
-            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)];
+            nonce = _c.apply(void 0, [_d]);
+            if (!((_b = transactionsDetail.maxFee) !== null && _b !== void 0))
+              return [3 /*break*/, 4];
+            _e = _b;
+            return [3 /*break*/, 6];
           case 4:
+            return [4 /*yield*/, this.estimateFee(transactions)];
+          case 5:
+            _e = _f.sent().amount;
+            _f.label = 6;
+          case 6:
+            maxFee = _e;
+            signerDetails = {
+              walletAddress: this.address,
+              nonce: nonce,
+              maxFee: maxFee,
+            };
+            return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
+          case 7:
             signature = _f.sent();
             calldata = __spreadArray(
               __spreadArray(
@@ -296,6 +343,7 @@ var Account = /** @class */ (function (_super) {
                 entry_point_selector: (0, hash_1.getSelectorFromName)('__execute__'),
                 calldata: calldata,
                 signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(signature),
+                max_fee: (0, number_1.toHex)((0, number_1.toBN)(maxFee)),
               }),
             ];
         }

package/account/interface.d.ts

@@ -4,6 +4,8 @@ import {
   AddTransactionResponse,
   Call,
   DeployContractPayload,
+  EstimateFeeResponse,
+  Invocation,
   InvocationsDetails,
   Signature,
 } from '../types';
@@ -25,6 +27,18 @@ export declare abstract class AccountInterface extends ProviderInterface {
     payload: DeployContractPayload,
     abi?: Abi
   ): Promise<AddTransactionResponse>;
+  /**
+   * Estimate Fee for a method on starknet
+   *
+   * @param invocation the invocation object containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   * - signature - (defaults to []) the signature
+   *
+   * @returns response from addTransaction
+   */
+  abstract estimateFee(invocation: Invocation): Promise<EstimateFeeResponse>;
   /**
    * Invoke execute function in account contract
    *

package/contract/contractFactory.d.ts

@@ -0,0 +1,36 @@
+import { Account } from '../account';
+import { Provider } from '../provider';
+import { Abi, CompiledContract, RawCalldata } from '../types';
+import { BigNumberish } from '../utils/number';
+import { Contract } from './default';
+export declare class ContractFactory {
+  abi: Abi;
+  compiledContract: CompiledContract;
+  providerOrAccount: Provider | Account;
+  constructor(
+    compiledContract: CompiledContract,
+    providerOrAccount?: Provider | Account,
+    abi?: Abi
+  );
+  /**
+   * Deploys contract and returns new instance of the Contract
+   *
+   * @param constructorCalldata - Constructor Calldata
+   * @param addressSalt (optional) - Address Salt for deployment
+   * @returns deployed Contract
+   */
+  deploy(constructorCalldata?: RawCalldata, addressSalt?: BigNumberish): Promise<Contract>;
+  /**
+   * Attaches to new Provider or Account
+   *
+   * @param providerOrAccount - new Provider or Account to attach to
+   */
+  connect(providerOrAccount: Provider | Account): ContractFactory;
+  /**
+   * Attaches current abi and provider or account to the new address
+   *
+   * @param address - Contract address
+   * @returns Contract
+   */
+  attach(address: string): Contract;
+}

package/contract/contractFactory.js

@@ -0,0 +1,218 @@
+'use strict';
+var __awaiter =
+  (this && this.__awaiter) ||
+  function (thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P
+        ? value
+        : new P(function (resolve) {
+            resolve(value);
+          });
+    }
+    return new (P || (P = Promise))(function (resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator['throw'](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+var __generator =
+  (this && this.__generator) ||
+  function (thisArg, body) {
+    var _ = {
+        label: 0,
+        sent: function () {
+          if (t[0] & 1) throw t[1];
+          return t[1];
+        },
+        trys: [],
+        ops: [],
+      },
+      f,
+      y,
+      t,
+      g;
+    return (
+      (g = { next: verb(0), throw: verb(1), return: verb(2) }),
+      typeof Symbol === 'function' &&
+        (g[Symbol.iterator] = function () {
+          return this;
+        }),
+      g
+    );
+    function verb(n) {
+      return function (v) {
+        return step([n, v]);
+      };
+    }
+    function step(op) {
+      if (f) throw new TypeError('Generator is already executing.');
+      while (_)
+        try {
+          if (
+            ((f = 1),
+            y &&
+              (t =
+                op[0] & 2
+                  ? y['return']
+                  : op[0]
+                  ? y['throw'] || ((t = y['return']) && t.call(y), 0)
+                  : y.next) &&
+              !(t = t.call(y, op[1])).done)
+          )
+            return t;
+          if (((y = 0), t)) op = [op[0] & 2, t.value];
+          switch (op[0]) {
+            case 0:
+            case 1:
+              t = op;
+              break;
+            case 4:
+              _.label++;
+              return { value: op[1], done: false };
+            case 5:
+              _.label++;
+              y = op[1];
+              op = [0];
+              continue;
+            case 7:
+              op = _.ops.pop();
+              _.trys.pop();
+              continue;
+            default:
+              if (
+                !((t = _.trys), (t = t.length > 0 && t[t.length - 1])) &&
+                (op[0] === 6 || op[0] === 2)
+              ) {
+                _ = 0;
+                continue;
+              }
+              if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) {
+                _.label = op[1];
+                break;
+              }
+              if (op[0] === 6 && _.label < t[1]) {
+                _.label = t[1];
+                t = op;
+                break;
+              }
+              if (t && _.label < t[2]) {
+                _.label = t[2];
+                _.ops.push(op);
+                break;
+              }
+              if (t[2]) _.ops.pop();
+              _.trys.pop();
+              continue;
+          }
+          op = body.call(thisArg, _);
+        } catch (e) {
+          op = [6, e];
+          y = 0;
+        } finally {
+          f = t = 0;
+        }
+      if (op[0] & 5) throw op[1];
+      return { value: op[0] ? op[1] : void 0, done: true };
+    }
+  };
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, '__esModule', { value: true });
+exports.ContractFactory = void 0;
+var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
+var provider_1 = require('../provider');
+var default_1 = require('./default');
+var ContractFactory = /** @class */ (function () {
+  function ContractFactory(
+    compiledContract,
+    providerOrAccount,
+    abi // abi can be different from the deployed contract ie for proxy contracts
+  ) {
+    if (providerOrAccount === void 0) {
+      providerOrAccount = provider_1.defaultProvider;
+    }
+    if (abi === void 0) {
+      abi = compiledContract.abi;
+    }
+    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
+   */
+  ContractFactory.prototype.deploy = function (constructorCalldata, addressSalt) {
+    return __awaiter(this, void 0, void 0, function () {
+      var _a, address, code, transaction_hash, contractInstance;
+      return __generator(this, function (_b) {
+        switch (_b.label) {
+          case 0:
+            return [
+              4 /*yield*/,
+              this.providerOrAccount.deployContract({
+                contract: this.compiledContract,
+                constructorCalldata: constructorCalldata,
+                addressSalt: addressSalt,
+              }),
+            ];
+          case 1:
+            (_a = _b.sent()),
+              (address = _a.address),
+              (code = _a.code),
+              (transaction_hash = _a.transaction_hash);
+            (0,
+            minimalistic_assert_1.default)(code === 'TRANSACTION_RECEIVED' && Boolean(address), 'Deployment of the contract failed');
+            contractInstance = new default_1.Contract(
+              this.compiledContract.abi,
+              address,
+              this.providerOrAccount
+            );
+            contractInstance.deployTransactionHash = transaction_hash;
+            return [2 /*return*/, contractInstance];
+        }
+      });
+    });
+  };
+  /**
+   * Attaches to new Provider or Account
+   *
+   * @param providerOrAccount - new Provider or Account to attach to
+   */
+  ContractFactory.prototype.connect = function (providerOrAccount) {
+    this.providerOrAccount = providerOrAccount;
+    return this;
+  };
+  /**
+   * Attaches current abi and provider or account to the new address
+   *
+   * @param address - Contract address
+   * @returns Contract
+   */
+  ContractFactory.prototype.attach = function (address) {
+    return new default_1.Contract(this.abi, address, this.providerOrAccount);
+  };
+  return ContractFactory;
+})();
+exports.ContractFactory = ContractFactory;

package/contract/default.d.ts

@@ -0,0 +1,143 @@
+import { AccountInterface } from '../account';
+import { ProviderInterface } from '../provider';
+import {
+  Abi,
+  AbiEntry,
+  AddTransactionResponse,
+  Args,
+  AsyncContractFunction,
+  Calldata,
+  ContractFunction,
+  Invocation,
+  ParsedStruct,
+  Result,
+  StructAbi,
+} from '../types';
+import { BigNumberish } from '../utils/number';
+import { ContractInterface } from './interface';
+export declare class Contract implements ContractInterface {
+  abi: Abi;
+  address: string;
+  providerOrAccount: ProviderInterface | AccountInterface;
+  deployTransactionHash?: string;
+  protected readonly structs: {
+    [name: string]: StructAbi;
+  };
+  readonly functions: {
+    [name: string]: AsyncContractFunction;
+  };
+  readonly callStatic: {
+    [name: string]: AsyncContractFunction;
+  };
+  readonly populateTransaction: {
+    [name: string]: ContractFunction;
+  };
+  readonly estimateFee: {
+    [name: string]: ContractFunction;
+  };
+  readonly [key: string]: AsyncContractFunction | any;
+  /**
+   * Contract class to handle contract methods
+   *
+   * @param abi - Abi of the contract object
+   * @param address (optional) - address to connect to
+   * @param providerOrAccount (optional) - Provider or Account to attach to
+   */
+  constructor(abi: Abi, address: string, providerOrAccount?: ProviderInterface | AccountInterface);
+  /**
+   * Saves the address of the contract deployed on network that will be used for interaction
+   *
+   * @param address - address of the contract
+   */
+  attach(address: string): void;
+  /**
+   * Attaches to new Provider or Account
+   *
+   * @param providerOrAccount - new Provider or Account to attach to
+   */
+  connect(providerOrAccount: ProviderInterface | AccountInterface): void;
+  /**
+   * Resolves when contract is deployed on the network or when no deployment transaction is found
+   *
+   * @returns Promise that resolves when contract is deployed on the network or when no deployment transaction is found
+   * @throws When deployment fails
+   */
+  deployed(): Promise<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
+   */
+  protected validateMethodAndArgs(type: 'INVOKE' | 'CALL', method: string, args?: Array<any>): void;
+  /**
+   * Deep parse of the object that has been passed to the method
+   *
+   * @param struct - struct that needs to be calculated
+   * @return {number} - number of members for the given struct
+   */
+  private calculateStructMembers;
+  /**
+   * 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
+   */
+  protected parseCalldataValue(
+    element: ParsedStruct | BigNumberish | BigNumberish[],
+    type: string
+  ): string | string[];
+  /**
+   * 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
+   */
+  protected parseResponseStruct(
+    responseIterator: Iterator<string>,
+    type: string
+  ): BigNumberish | ParsedStruct;
+  /**
+   * 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
+   */
+  protected parseCalldataField(argsIterator: Iterator<any>, input: AbiEntry): string | string[];
+  /**
+   * 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
+   */
+  protected compileCalldata(args: Array<any>, inputs: AbiEntry[]): Calldata;
+  /**
+   * 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
+   */
+  protected parseResponseField(
+    responseIterator: Iterator<string>,
+    output: AbiEntry,
+    parsedResult?: Args
+  ): any;
+  /**
+   * 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
+   */
+  protected parseResponse(method: string, response: string[]): Result;
+  invoke(method: string, args?: Array<any>): Promise<AddTransactionResponse>;
+  call(method: string, args?: Array<any>): Promise<Result>;
+  estimate(method: string, args?: Array<any>): Promise<import('../types').EstimateFeeResponse>;
+  populate(method: string, args?: Array<any>): Invocation;
+}