starknet 4.9.0 → 4.10.0

package/provider/rpc.js

@@ -1,4 +1,15 @@
 "use strict";
+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) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -52,9 +63,10 @@ var RpcProvider = /** @class */ (function () {
     function RpcProvider(optionsOrProvider) {
         var _this = this;
         this.responseParser = new rpc_1.RPCResponseParser();
-        var nodeUrl = optionsOrProvider.nodeUrl, retries = optionsOrProvider.retries;
+        var nodeUrl = optionsOrProvider.nodeUrl, retries = optionsOrProvider.retries, headers = optionsOrProvider.headers;
         this.nodeUrl = nodeUrl;
         this.retries = retries || 200;
+        this.headers = __assign({ 'Content-Type': 'application/json' }, headers);
         this.getChainId().then(function (chainId) {
             _this.chainId = chainId;
         });
@@ -63,7 +75,7 @@ var RpcProvider = /** @class */ (function () {
         return (0, fetchPonyfill_1.default)(this.nodeUrl, {
             method: 'POST',
             body: (0, json_1.stringify)({ method: method, jsonrpc: '2.0', params: params, id: 0 }),
-            headers: { 'Content-Type': 'application/json' },
+            headers: this.headers,
         });
     };
     RpcProvider.prototype.errorHandler = function (error) {
@@ -243,6 +255,7 @@ var RpcProvider = /** @class */ (function () {
         });
     };
     RpcProvider.prototype.getClassAt = function (contractAddress, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             var block_id;
             return __generator(this, function (_a) {

package/provider/sequencer.d.ts

@@ -5,7 +5,7 @@ import { DeclareContractTransaction, DeployAccountContractTransaction } from '..
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier } from './utils';
-declare type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
+declare type NetworkName = 'mainnet-alpha' | 'goerli-alpha' | 'goerli-alpha-2';
 export declare type SequencerProviderOptions = {
     network: NetworkName;
 } | {
@@ -13,15 +13,17 @@ export declare type SequencerProviderOptions = {
     feederGatewayUrl?: string;
     gatewayUrl?: string;
     chainId?: StarknetChainId;
+    headers?: object;
 };
 export declare class SequencerProvider implements ProviderInterface {
     baseUrl: string;
     feederGatewayUrl: string;
     gatewayUrl: string;
     chainId: StarknetChainId;
+    headers: object | undefined;
     private responseParser;
     constructor(optionsOrProvider?: SequencerProviderOptions);
-    protected static getNetworkFromName(name: NetworkName): "https://alpha-mainnet.starknet.io" | "https://alpha4.starknet.io";
+    protected static getNetworkFromName(name: NetworkName): "https://alpha-mainnet.starknet.io" | "https://alpha4.starknet.io" | "https://alpha4-2.starknet.io";
     protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId;
     private getFetchUrl;
     private getFetchMethod;

package/provider/sequencer.js

@@ -1,4 +1,15 @@
 "use strict";
+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) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -79,7 +90,7 @@ function isEmptyQueryObject(obj) {
 }
 var SequencerProvider = /** @class */ (function () {
     function SequencerProvider(optionsOrProvider) {
-        if (optionsOrProvider === void 0) { optionsOrProvider = { network: 'goerli-alpha' }; }
+        if (optionsOrProvider === void 0) { optionsOrProvider = { network: 'goerli-alpha-2' }; }
         var _a;
         this.responseParser = new sequencer_1.SequencerAPIResponseParser();
         if ('network' in optionsOrProvider) {
@@ -94,6 +105,7 @@ var SequencerProvider = /** @class */ (function () {
             this.gatewayUrl = (0, url_1.buildUrl)(this.baseUrl, 'gateway', optionsOrProvider.gatewayUrl);
             this.chainId =
                 (_a = optionsOrProvider.chainId) !== null && _a !== void 0 ? _a : SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
+            this.headers = optionsOrProvider === null || optionsOrProvider === void 0 ? void 0 : optionsOrProvider.headers;
         }
     }
     SequencerProvider.getNetworkFromName = function (name) {
@@ -101,6 +113,9 @@ var SequencerProvider = /** @class */ (function () {
             case 'mainnet-alpha':
                 return 'https://alpha-mainnet.starknet.io';
             case 'goerli-alpha':
+                return 'https://alpha4.starknet.io';
+            case 'goerli-alpha-2':
+                return 'https://alpha4-2.starknet.io';
             default:
                 return 'https://alpha4.starknet.io';
         }
@@ -149,11 +164,9 @@ var SequencerProvider = /** @class */ (function () {
     };
     SequencerProvider.prototype.getHeaders = function (method) {
         if (method === 'POST') {
-            return {
-                'Content-Type': 'application/json',
-            };
+            return __assign({ 'Content-Type': 'application/json' }, this.headers);
         }
-        return undefined;
+        return this.headers;
     };
     // typesafe fetch
     SequencerProvider.prototype.fetchEndpoint = function (endpoint) {

package/signer/default.d.ts

@@ -6,8 +6,8 @@ export declare class Signer implements SignerInterface {
     protected keyPair: KeyPair;
     constructor(keyPair?: KeyPair);
     getPubKey(): Promise<string>;
+    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
     signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
-    signDeclareTransaction({ classHash, senderAddress, chainId, maxFee, version, nonce }: DeclareSignerDetails): Promise<Signature>;
     signDeployAccountTransaction({ classHash, contractAddress, constructorCalldata, addressSalt, maxFee, version, chainId, nonce, }: DeployAccountSignerDetails): Promise<Signature>;
-    signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
+    signDeclareTransaction({ classHash, senderAddress, chainId, maxFee, version, nonce }: DeclareSignerDetails): Promise<Signature>;
 }

package/signer/default.js

@@ -53,6 +53,15 @@ var Signer = /** @class */ (function () {
             });
         });
     };
+    Signer.prototype.signMessage = function (typedData, accountAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            var msgHash;
+            return __generator(this, function (_a) {
+                msgHash = (0, typedData_1.getMessageHash)(typedData, accountAddress);
+                return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
+            });
+        });
+    };
     Signer.prototype.signTransaction = function (transactions, transactionsDetail, abis) {
         return __awaiter(this, void 0, void 0, function () {
             var calldata, msgHash;
@@ -66,18 +75,6 @@ var Signer = /** @class */ (function () {
             });
         });
     };
-    Signer.prototype.signDeclareTransaction = function (
-    // contractClass: ContractClass,  // Should be used once class hash is present in ContractClass
-    _a) {
-        var classHash = _a.classHash, senderAddress = _a.senderAddress, chainId = _a.chainId, maxFee = _a.maxFee, version = _a.version, nonce = _a.nonce;
-        return __awaiter(this, void 0, void 0, function () {
-            var msgHash;
-            return __generator(this, function (_b) {
-                msgHash = (0, hash_1.calculateDeclareTransactionHash)(classHash, senderAddress, version, maxFee, chainId, nonce);
-                return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
-            });
-        });
-    };
     Signer.prototype.signDeployAccountTransaction = function (_a) {
         var classHash = _a.classHash, contractAddress = _a.contractAddress, constructorCalldata = _a.constructorCalldata, addressSalt = _a.addressSalt, maxFee = _a.maxFee, version = _a.version, chainId = _a.chainId, nonce = _a.nonce;
         return __awaiter(this, void 0, void 0, function () {
@@ -88,11 +85,14 @@ var Signer = /** @class */ (function () {
             });
         });
     };
-    Signer.prototype.signMessage = function (typedData, accountAddress) {
+    Signer.prototype.signDeclareTransaction = function (
+    // contractClass: ContractClass,  // Should be used once class hash is present in ContractClass
+    _a) {
+        var classHash = _a.classHash, senderAddress = _a.senderAddress, chainId = _a.chainId, maxFee = _a.maxFee, version = _a.version, nonce = _a.nonce;
         return __awaiter(this, void 0, void 0, function () {
             var msgHash;
-            return __generator(this, function (_a) {
-                msgHash = (0, typedData_1.getMessageHash)(typedData, accountAddress);
+            return __generator(this, function (_b) {
+                msgHash = (0, hash_1.calculateDeclareTransactionHash)(classHash, senderAddress, version, maxFee, chainId, nonce);
                 return [2 /*return*/, (0, ellipticCurve_1.sign)(this.keyPair, msgHash)];
             });
         });

package/signer/interface.d.ts

@@ -32,6 +32,7 @@ export declare abstract class SignerInterface {
     abstract signTransaction(transactions: Call[], transactionsDetail: InvocationsSignerDetails, abis?: Abi[]): Promise<Signature>;
     /**
      * Signs a DEPLOY_ACCOUNT transaction with the starknet private key and returns the signature
+     *
      * @param transaction
      * - contractAddress - the computed address of the contract
      * - constructorCalldata - calldata to be passed in deploy constructor
@@ -45,6 +46,7 @@ export declare abstract class SignerInterface {
     abstract signDeployAccountTransaction(transaction: DeployAccountSignerDetails): Promise<Signature>;
     /**
      * Signs a DECLARE transaction with the starknet private key and returns the signature
+     *
      * @param transaction
      * - classHash - computed class hash. Will be replaced by ContractClass in future once class hash is present in CompiledContract
      * - senderAddress - the address of the sender

package/src/account/default.ts

@@ -1,4 +1,4 @@
-import { ZERO } from '../constants';
+import { UDC, ZERO } from '../constants';
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
 import { BlockIdentifier } from '../provider/utils';
@@ -16,9 +16,14 @@ import {
   Signature,
 } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
 import { calculateContractAddressFromHash, transactionVersion } from '../utils/hash';
-import { BigNumberish, toBN } from '../utils/number';
+import { BigNumberish, toBN, toCairoBool } from '../utils/number';
 import { parseContract } from '../utils/provider';
 import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
@@ -228,6 +233,41 @@ export class Account extends Provider implements AccountInterface {
     );
   }
 
+  public async deploy(
+    {
+      classHash,
+      salt,
+      unique = true,
+      constructorCalldata = [],
+      isDevnet = false,
+    }: UniversalDeployerContractPayload,
+    additionalCalls: AllowArray<Call> = [], // support multicall
+    transactionsDetail: InvocationsDetails = {}
+  ): Promise<InvokeFunctionResponse> {
+    const compiledConstructorCallData = compileCalldata(constructorCalldata);
+
+    const callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+
+    return this.execute(
+      [
+        {
+          contractAddress: isDevnet ? UDC.ADDRESS_DEVNET : UDC.ADDRESS,
+          entrypoint: UDC.ENTRYPOINT,
+          calldata: [
+            classHash,
+            salt,
+            toCairoBool(unique),
+            compiledConstructorCallData.length,
+            ...compiledConstructorCallData,
+          ],
+        },
+        ...callsArray,
+      ],
+      undefined,
+      transactionsDetail
+    );
+  }
+
   public async deployAccount(
     {
       classHash,

package/src/account/interface.ts

@@ -13,7 +13,12 @@ import {
   InvokeFunctionResponse,
   Signature,
 } from '../types';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
@@ -71,7 +76,7 @@ export abstract class AccountInterface extends ProviderInterface {
    * Estimate Fee for executing a DEPLOY_ACCOUNT transaction on starknet
    *
    * @param contractPayload the payload object containing:
-   * - contract - the compiled contract to be declared
+   * - contract - the compiled contract to be deployed
    * - classHash - the class hash of the compiled contract. This can be obtained by using starknet-cli.
    *
    * @returns response from estimate_fee
@@ -101,6 +106,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Declares a given compiled contract (json) to starknet
+   * 
    * @param contractPayload transaction payload to be deployed containing:
   - contract: compiled contract code
   - classHash: computed class hash of compiled contract
@@ -116,13 +122,32 @@ export abstract class AccountInterface extends ProviderInterface {
     transactionsDetail?: InvocationsDetails
   ): Promise<DeclareContractResponse>;
 
+  /**
+   * @param deployContractPayload containing
+   * - classHash: computed class hash of compiled contract
+   * - salt: address salt
+   * - unique: bool if true ensure unique salt
+   * - calldata: constructor calldata
+   * @param additionalCalls - optional additional calls array to support multicall
+   * @param transactionsDetail Invocation Details containing:
+   *  - optional nonce
+   *  - optional version
+   *  - optional maxFee
+   */
+  public abstract deploy(
+    deployContractPayload: UniversalDeployerContractPayload,
+    additionalCalls?: AllowArray<Call>,
+    transactionsDetail?: InvocationsDetails
+  ): Promise<InvokeFunctionResponse>;
+
   /**
    * Deploy the account on Starknet
+   * 
    * @param contractPayload transaction payload to be deployed containing:
-   * - classHash: computed class hash of compiled contract
-   * - constructor calldata
-   * - address salt  
-  - signature
+  - classHash: computed class hash of compiled contract
+  - optional constructor calldata
+  - optional address salt  
+  - optional contractAddress
    * @param transactionsDetail Invocation Details containing:
   - optional nonce
   - optional version
@@ -157,7 +182,7 @@ export abstract class AccountInterface extends ProviderInterface {
   /**
    * Verify a signature of a JSON object
    *
-   * @param json - JSON object to be verified
+   * @param typedData - 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
@@ -177,6 +202,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Gets the nonce of the account with respect to a specific block
+   *
    * @param  {BlockIdentifier} blockIdentifier - optional blockIdentifier. Defaults to 'pending'
    * @returns nonce of the account
    */
@@ -184,6 +210,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Gets Suggested Max Fee based on the transaction type
+   *
    * @param  {EstimateFeeAction} estimateFeeAction
    * @param  {EstimateFeeDetails} details
    * @returns suggestedMaxFee

package/src/constants.ts

@@ -11,6 +11,7 @@ export const MASK_251 = TWO.pow(toBN(251));
 export enum StarknetChainId {
   MAINNET = '0x534e5f4d41494e', // encodeShortString('SN_MAIN'),
   TESTNET = '0x534e5f474f45524c49', // encodeShortString('SN_GOERLI'),
+  TESTNET2 = '0x534e5f474f45524c4932',
 }
 export enum TransactionHashPrefix {
   DECLARE = '0x6465636c617265', // encodeShortString('declare'),
@@ -20,6 +21,12 @@ export enum TransactionHashPrefix {
   L1_HANDLER = '0x6c315f68616e646c6572', // encodeShortString('l1_handler'),
 }
 
+export const UDC = {
+  ADDRESS: '0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf',
+  ENTRYPOINT: 'deployContract',
+  ADDRESS_DEVNET: '0x25fcb74260022bd8ed7e8d542408941826b53345e478b8303d6f31744838a36',
+};
+
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.

package/src/contract/default.ts

@@ -204,30 +204,14 @@ export class Contract implements ContractInterface {
     });
   }
 
-  /**
-   * Saves the address of the contract deployed on network that will be used for interaction
-   *
-   * @param address - address of the contract
-   */
   public attach(address: string): void {
     this.address = address;
   }
 
-  /**
-   * Attaches to new Provider or Account
-   *
-   * @param providerOrAccount - new Provider or Account to attach to
-   */
   public connect(providerOrAccount: ProviderInterface | AccountInterface) {
     this.providerOrAccount = providerOrAccount;
   }
 
-  /**
-   * 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
-   */
   public async deployed(): Promise<Contract> {
     if (this.deployTransactionHash) {
       await this.providerOrAccount.waitForTransaction(this.deployTransactionHash);
@@ -236,6 +220,129 @@ export class Contract implements ContractInterface {
     return this;
   }
 
+  public async call(
+    method: string,
+    args: Array<any> = [],
+    {
+      blockIdentifier = 'pending',
+    }: {
+      blockIdentifier?: BlockIdentifier;
+    } = {}
+  ): Promise<Result> {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+
+    // validate method and args
+    this.validateMethodAndArgs('CALL', method, args);
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+
+    // compile calldata
+    const calldata = this.compileCalldata(args, inputs);
+    return this.providerOrAccount
+      .callContract(
+        {
+          contractAddress: this.address,
+          calldata,
+          entrypoint: method,
+        },
+        blockIdentifier
+      )
+      .then((x) => this.parseResponse(method, x.result));
+  }
+
+  public invoke(
+    method: string,
+    args: Array<any> = [],
+    options: Overrides = {}
+  ): Promise<InvokeFunctionResponse> {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+    // validate method and args
+    this.validateMethodAndArgs('INVOKE', method, args);
+
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+    const inputsLength = inputs.reduce((acc, input) => {
+      if (!/_len$/.test(input.name)) {
+        return acc + 1;
+      }
+      return acc;
+    }, 0);
+
+    if (args.length !== inputsLength) {
+      throw Error(
+        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+      );
+    }
+    // compile calldata
+    const calldata = this.compileCalldata(args, inputs);
+
+    const invocation = {
+      contractAddress: this.address,
+      calldata,
+      entrypoint: method,
+    };
+    if ('execute' in this.providerOrAccount) {
+      return this.providerOrAccount.execute(invocation, undefined, {
+        maxFee: options.maxFee,
+        nonce: options.nonce,
+      });
+    }
+
+    if (!options.nonce) {
+      throw new Error(`Nonce is required when invoking a function without an account`);
+    }
+
+    // eslint-disable-next-line no-console
+    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
+
+    return this.providerOrAccount.invokeFunction(
+      {
+        ...invocation,
+        signature: options.signature || [],
+      },
+      {
+        nonce: options.nonce,
+      }
+    );
+  }
+
+  public async estimate(method: string, args: Array<any> = []) {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+
+    // validate method and args
+    this.validateMethodAndArgs('INVOKE', method, args);
+    const invocation = this.populateTransaction[method](...args);
+    if ('estimateInvokeFee' in this.providerOrAccount) {
+      return this.providerOrAccount.estimateInvokeFee(invocation);
+    }
+    throw Error('Contract must be connected to the account contract to estimate');
+  }
+
+  public populate(method: string, args: Array<any> = []): Call {
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+    return {
+      contractAddress: this.address,
+      entrypoint: method,
+      calldata: this.compileCalldata(args, inputs),
+    };
+  }
+
+  /**
+   * 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(struct: string): number {
+    return this.structs[struct].members.reduce((acc, member) => {
+      if (member.type === 'felt') {
+        return acc + 1;
+      }
+      return acc + this.calculateStructMembers(member.type);
+    }, 0);
+  }
+
   /**
    * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
    *
@@ -337,22 +444,6 @@ export class Contract implements ContractInterface {
     });
   }
 
-  /**
-   * 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(struct: string): number {
-    return this.structs[struct].members.reduce((acc, member) => {
-      if (member.type === 'felt') {
-        return acc + 1;
-      }
-      return acc + this.calculateStructMembers(member.type);
-    }, 0);
-  }
-
   /**
    * Deep parse of the object that has been passed to the method
    *
@@ -539,112 +630,4 @@ export class Contract implements ContractInterface {
       return acc;
     }, [] as Result);
   }
-
-  public invoke(
-    method: string,
-    args: Array<any> = [],
-    options: Overrides = {}
-  ): Promise<InvokeFunctionResponse> {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-    // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
-
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    const inputsLength = inputs.reduce((acc, input) => {
-      if (!/_len$/.test(input.name)) {
-        return acc + 1;
-      }
-      return acc;
-    }, 0);
-
-    if (args.length !== inputsLength) {
-      throw Error(
-        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-      );
-    }
-    // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
-
-    const invocation = {
-      contractAddress: this.address,
-      calldata,
-      entrypoint: method,
-    };
-    if ('execute' in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation, undefined, {
-        maxFee: options.maxFee,
-        nonce: options.nonce,
-      });
-    }
-
-    if (!options.nonce) {
-      throw new Error(`Nonce is required when invoking a function without an account`);
-    }
-
-    // eslint-disable-next-line no-console
-    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
-
-    return this.providerOrAccount.invokeFunction(
-      {
-        ...invocation,
-        signature: options.signature || [],
-      },
-      {
-        nonce: options.nonce,
-      }
-    );
-  }
-
-  public async call(
-    method: string,
-    args: Array<any> = [],
-    {
-      blockIdentifier = 'pending',
-    }: {
-      blockIdentifier?: BlockIdentifier;
-    } = {}
-  ): Promise<Result> {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-
-    // validate method and args
-    this.validateMethodAndArgs('CALL', method, args);
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-
-    // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
-    return this.providerOrAccount
-      .callContract(
-        {
-          contractAddress: this.address,
-          calldata,
-          entrypoint: method,
-        },
-        blockIdentifier
-      )
-      .then((x) => this.parseResponse(method, x.result));
-  }
-
-  public async estimate(method: string, args: Array<any> = []) {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-
-    // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
-    const invocation = this.populateTransaction[method](...args);
-    if ('estimateInvokeFee' in this.providerOrAccount) {
-      return this.providerOrAccount.estimateInvokeFee(invocation);
-    }
-    throw Error('Contract must be connected to the account contract to estimate');
-  }
-
-  public populate(method: string, args: Array<any> = []): Call {
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    return {
-      contractAddress: this.address,
-      entrypoint: method,
-      calldata: this.compileCalldata(args, inputs),
-    };
-  }
 }