starknet 6.9.0 → 6.10.1

package/dist/constants.d.ts

@@ -0,0 +1,70 @@
+import { ETransactionVersion } from './types/api';
+import { ValuesType } from './types/helpers/valuesType';
+export { IS_BROWSER } from './utils/encode';
+/**
+ * Cairo Felt support storing max 31 character
+ */
+export declare const TEXT_TO_FELT_MAX_LEN = 31;
+/**
+ * Alternatively use directly from api specification
+ * types.RPC.ETransactionVersion
+ * For BN do BigInt(TRANSACTION_VERSION.*)
+ */
+export { ETransactionVersion as TRANSACTION_VERSION };
+export declare const ZERO = 0n;
+export declare const MASK_250: bigint;
+export declare const API_VERSION = 0n;
+export declare const PRIME: bigint;
+export declare const MAX_STORAGE_ITEM_SIZE = 256n;
+export declare const ADDR_BOUND: bigint;
+export declare const RANGE_FELT: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare const RANGE_I128: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare const RANGE_U128: {
+    readonly min: bigint;
+    readonly max: bigint;
+};
+export declare const BaseUrl: {
+    readonly SN_MAIN: "https://alpha-mainnet.starknet.io";
+    readonly SN_SEPOLIA: "https://alpha-sepolia.starknet.io";
+};
+export type BaseUrl = ValuesType<typeof BaseUrl>;
+export declare const NetworkName: {
+    readonly SN_MAIN: "SN_MAIN";
+    readonly SN_SEPOLIA: "SN_SEPOLIA";
+};
+export type NetworkName = ValuesType<typeof NetworkName>;
+export declare const StarknetChainId: {
+    readonly SN_MAIN: "0x534e5f4d41494e";
+    readonly SN_SEPOLIA: "0x534e5f5345504f4c4941";
+};
+export type StarknetChainId = ValuesType<typeof StarknetChainId>;
+export declare const TransactionHashPrefix: {
+    readonly DECLARE: "0x6465636c617265";
+    readonly DEPLOY: "0x6465706c6f79";
+    readonly DEPLOY_ACCOUNT: "0x6465706c6f795f6163636f756e74";
+    readonly INVOKE: "0x696e766f6b65";
+    readonly L1_HANDLER: "0x6c315f68616e646c6572";
+};
+export type TransactionHashPrefix = ValuesType<typeof TransactionHashPrefix>;
+export declare const FeeMarginPercentage: {
+    readonly L1_BOUND_MAX_AMOUNT: 50;
+    readonly L1_BOUND_MAX_PRICE_PER_UNIT: 50;
+    readonly MAX_FEE: 50;
+};
+export type FeeMarginPercentage = ValuesType<typeof FeeMarginPercentage>;
+export declare const UDC: {
+    readonly ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf";
+    readonly ENTRYPOINT: "deployContract";
+};
+export type UDC = ValuesType<typeof UDC>;
+export declare const RPC_DEFAULT_VERSION = "v0_7";
+export declare const RPC_NODES: {
+    readonly SN_MAIN: readonly ["https://starknet-mainnet.public.blastapi.io/rpc/v0_7", "https://free-rpc.nethermind.io/mainnet-juno/v0_7"];
+    readonly SN_SEPOLIA: readonly ["https://starknet-sepolia.public.blastapi.io/rpc/v0_7", "https://free-rpc.nethermind.io/sepolia-juno/v0_7"];
+};

package/dist/constants.mjs

@@ -0,0 +1,60 @@
+import { ETransactionVersion } from "./types/api/index.mjs";
+export { IS_BROWSER } from "./utils/encode.mjs";
+export const TEXT_TO_FELT_MAX_LEN = 31;
+export { ETransactionVersion as TRANSACTION_VERSION };
+export const ZERO = 0n;
+export const MASK_250 = 2n ** 250n - 1n;
+export const API_VERSION = ZERO;
+export const PRIME = 2n ** 251n + 17n * 2n ** 192n + 1n;
+export const MAX_STORAGE_ITEM_SIZE = 256n;
+export const ADDR_BOUND = 2n ** 251n - MAX_STORAGE_ITEM_SIZE;
+const range = (min, max) => ({ min, max });
+export const RANGE_FELT = range(ZERO, PRIME - 1n);
+export const RANGE_I128 = range(-(2n ** 127n), 2n ** 127n - 1n);
+export const RANGE_U128 = range(ZERO, 2n ** 128n - 1n);
+export const BaseUrl = {
+  SN_MAIN: "https://alpha-mainnet.starknet.io",
+  SN_SEPOLIA: "https://alpha-sepolia.starknet.io"
+};
+export const NetworkName = {
+  SN_MAIN: "SN_MAIN",
+  SN_SEPOLIA: "SN_SEPOLIA"
+};
+export const StarknetChainId = {
+  SN_MAIN: "0x534e5f4d41494e",
+  // encodeShortString('SN_MAIN'),
+  SN_SEPOLIA: "0x534e5f5345504f4c4941"
+  // encodeShortString('SN_SEPOLIA')
+};
+export const TransactionHashPrefix = {
+  DECLARE: "0x6465636c617265",
+  // encodeShortString('declare'),
+  DEPLOY: "0x6465706c6f79",
+  // encodeShortString('deploy'),
+  DEPLOY_ACCOUNT: "0x6465706c6f795f6163636f756e74",
+  // encodeShortString('deploy_account'),
+  INVOKE: "0x696e766f6b65",
+  // encodeShortString('invoke'),
+  L1_HANDLER: "0x6c315f68616e646c6572"
+  // encodeShortString('l1_handler'),
+};
+export const FeeMarginPercentage = {
+  L1_BOUND_MAX_AMOUNT: 50,
+  L1_BOUND_MAX_PRICE_PER_UNIT: 50,
+  MAX_FEE: 50
+};
+export const UDC = {
+  ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
+  ENTRYPOINT: "deployContract"
+};
+export const RPC_DEFAULT_VERSION = "v0_7";
+export const RPC_NODES = {
+  SN_MAIN: [
+    `https://starknet-mainnet.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
+    `https://free-rpc.nethermind.io/mainnet-juno/${RPC_DEFAULT_VERSION}`
+  ],
+  SN_SEPOLIA: [
+    `https://starknet-sepolia.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
+    `https://free-rpc.nethermind.io/sepolia-juno/${RPC_DEFAULT_VERSION}`
+  ]
+};

package/dist/contract/contractFactory.cjs

@@ -0,0 +1,93 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContractFactory = void 0;
+var _types = require("../types/index.cjs");
+var _assert = _interopRequireDefault(require("../utils/assert.cjs"));
+var _calldata = require("../utils/calldata/index.cjs");
+var _default = require("./default.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ContractFactory {
+  compiledContract;
+  account;
+  abi;
+  classHash;
+  casm;
+  compiledClassHash;
+  CallData;
+  /**
+   * @param params CFParams
+   *  - compiledContract: CompiledContract;
+   *  - account: AccountInterface;
+   *  - casm?: CairoAssembly;
+   *  - classHash?: string;
+   *  - compiledClassHash?: string;
+   *  - abi?: Abi;
+   */
+  constructor(params) {
+    this.compiledContract = params.compiledContract;
+    this.account = params.account;
+    this.casm = params.casm;
+    this.abi = params.abi ?? params.compiledContract.abi;
+    this.classHash = params.classHash;
+    this.compiledClassHash = params.compiledClassHash;
+    this.CallData = new _calldata.CallData(this.abi);
+  }
+  /**
+   * Deploys contract and returns new instance of the Contract
+   *
+   * If contract is not declared it will first declare it, and then deploy
+   */
+  async deploy(...args) {
+    const {
+      args: param,
+      options = {
+        parseRequest: true
+      }
+    } = (0, _default.splitArgsAndOptions)(args);
+    const constructorCalldata = (0, _default.getCalldata)(param, () => {
+      if (options.parseRequest) {
+        this.CallData.validate(_types.ValidateType.DEPLOY, "constructor", param);
+        return this.CallData.compile("constructor", param);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return param;
+    });
+    const {
+      deploy: {
+        contract_address,
+        transaction_hash
+      }
+    } = await this.account.declareAndDeploy({
+      contract: this.compiledContract,
+      casm: this.casm,
+      classHash: this.classHash,
+      compiledClassHash: this.compiledClassHash,
+      constructorCalldata,
+      salt: options.addressSalt
+    });
+    (0, _assert.default)(Boolean(contract_address), "Deployment of the contract failed");
+    const contractInstance = new _default.Contract(this.compiledContract.abi, contract_address, this.account);
+    contractInstance.deployTransactionHash = transaction_hash;
+    return contractInstance;
+  }
+  /**
+   * Attaches to new Account
+   *
+   * @param account - new Account to attach to
+   */
+  connect(account) {
+    this.account = account;
+    return this;
+  }
+  /**
+   * Attaches current abi and account to the new address
+   */
+  attach(address) {
+    return new _default.Contract(this.abi, address, this.account);
+  }
+  // ethers.js' getDeployTransaction can't be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
+}
+exports.ContractFactory = ContractFactory;

package/dist/contract/contractFactory.d.ts

@@ -0,0 +1,46 @@
+import { AccountInterface } from '../account';
+import { Abi, ArgsOrCalldataWithOptions, CairoAssembly, CompiledContract } from '../types';
+import { Contract } from './default';
+export type ContractFactoryParams = {
+    compiledContract: CompiledContract;
+    account: any;
+    casm?: CairoAssembly;
+    classHash?: string;
+    compiledClassHash?: string;
+    abi?: Abi;
+};
+export declare class ContractFactory {
+    compiledContract: CompiledContract;
+    account: AccountInterface;
+    abi: Abi;
+    classHash?: string;
+    casm?: CairoAssembly;
+    compiledClassHash?: string;
+    private CallData;
+    /**
+     * @param params CFParams
+     *  - compiledContract: CompiledContract;
+     *  - account: AccountInterface;
+     *  - casm?: CairoAssembly;
+     *  - classHash?: string;
+     *  - compiledClassHash?: string;
+     *  - abi?: Abi;
+     */
+    constructor(params: ContractFactoryParams);
+    /**
+     * Deploys contract and returns new instance of the Contract
+     *
+     * If contract is not declared it will first declare it, and then deploy
+     */
+    deploy(...args: ArgsOrCalldataWithOptions): Promise<Contract>;
+    /**
+     * Attaches to new Account
+     *
+     * @param account - new Account to attach to
+     */
+    connect(account: AccountInterface): ContractFactory;
+    /**
+     * Attaches current abi and account to the new address
+     */
+    attach(address: string): Contract;
+}

package/dist/contract/contractFactory.mjs

@@ -0,0 +1,83 @@
+import {
+  ValidateType
+} from "../types/index.mjs";
+import assert from "../utils/assert.mjs";
+import { CallData } from "../utils/calldata/index.mjs";
+import { Contract, getCalldata, splitArgsAndOptions } from "./default.mjs";
+export class ContractFactory {
+  compiledContract;
+  account;
+  abi;
+  classHash;
+  casm;
+  compiledClassHash;
+  CallData;
+  /**
+   * @param params CFParams
+   *  - compiledContract: CompiledContract;
+   *  - account: AccountInterface;
+   *  - casm?: CairoAssembly;
+   *  - classHash?: string;
+   *  - compiledClassHash?: string;
+   *  - abi?: Abi;
+   */
+  constructor(params) {
+    this.compiledContract = params.compiledContract;
+    this.account = params.account;
+    this.casm = params.casm;
+    this.abi = params.abi ?? params.compiledContract.abi;
+    this.classHash = params.classHash;
+    this.compiledClassHash = params.compiledClassHash;
+    this.CallData = new CallData(this.abi);
+  }
+  /**
+   * Deploys contract and returns new instance of the Contract
+   *
+   * If contract is not declared it will first declare it, and then deploy
+   */
+  async deploy(...args) {
+    const { args: param, options = { parseRequest: true } } = splitArgsAndOptions(args);
+    const constructorCalldata = getCalldata(param, () => {
+      if (options.parseRequest) {
+        this.CallData.validate(ValidateType.DEPLOY, "constructor", param);
+        return this.CallData.compile("constructor", param);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return param;
+    });
+    const {
+      deploy: { contract_address, transaction_hash }
+    } = await this.account.declareAndDeploy({
+      contract: this.compiledContract,
+      casm: this.casm,
+      classHash: this.classHash,
+      compiledClassHash: this.compiledClassHash,
+      constructorCalldata,
+      salt: options.addressSalt
+    });
+    assert(Boolean(contract_address), "Deployment of the contract failed");
+    const contractInstance = new Contract(
+      this.compiledContract.abi,
+      contract_address,
+      this.account
+    );
+    contractInstance.deployTransactionHash = transaction_hash;
+    return contractInstance;
+  }
+  /**
+   * Attaches to new Account
+   *
+   * @param account - new Account to attach to
+   */
+  connect(account) {
+    this.account = account;
+    return this;
+  }
+  /**
+   * Attaches current abi and account to the new address
+   */
+  attach(address) {
+    return new Contract(this.abi, address, this.account);
+  }
+  // ethers.js' getDeployTransaction can't be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation
+}

package/dist/contract/default.cjs

@@ -0,0 +1,269 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Contract = void 0;
+exports.getCalldata = getCalldata;
+exports.splitArgsAndOptions = void 0;
+var _provider = require("../provider/index.cjs");
+var _types = require("../types/index.cjs");
+var _assert = _interopRequireDefault(require("../utils/assert.cjs"));
+var _calldata = require("../utils/calldata/index.cjs");
+var _parser = require("../utils/calldata/parser/index.cjs");
+var _index = require("../utils/events/index.cjs");
+var _num = require("../utils/num.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const splitArgsAndOptions = args => {
+  const options = ["blockIdentifier", "parseRequest", "parseResponse", "formatResponse", "maxFee", "nonce", "signature", "addressSalt"];
+  const lastArg = args[args.length - 1];
+  if (typeof lastArg === "object" && options.some(x => x in lastArg)) {
+    return {
+      args,
+      options: args.pop()
+    };
+  }
+  return {
+    args
+  };
+};
+exports.splitArgsAndOptions = splitArgsAndOptions;
+function buildCall(contract, functionAbi) {
+  return async function (...args) {
+    const params = splitArgsAndOptions(args);
+    return contract.call(functionAbi.name, params.args, {
+      parseRequest: true,
+      parseResponse: true,
+      ...params.options
+    });
+  };
+}
+function buildInvoke(contract, functionAbi) {
+  return async function (...args) {
+    const params = splitArgsAndOptions(args);
+    return contract.invoke(functionAbi.name, params.args, {
+      parseRequest: true,
+      ...params.options
+    });
+  };
+}
+function buildDefault(contract, functionAbi) {
+  if (functionAbi.stateMutability === "view" || functionAbi.state_mutability === "view") {
+    return buildCall(contract, functionAbi);
+  }
+  return buildInvoke(contract, functionAbi);
+}
+function buildPopulate(contract, functionAbi) {
+  return function (...args) {
+    return contract.populate(functionAbi.name, args);
+  };
+}
+function buildEstimate(contract, functionAbi) {
+  return function (...args) {
+    return contract.estimate(functionAbi.name, args);
+  };
+}
+function getCalldata(args, callback) {
+  if (Array.isArray(args) && "__compiled__" in args) return args;
+  if (Array.isArray(args) && Array.isArray(args[0]) && "__compiled__" in args[0]) return args[0];
+  return callback();
+}
+class Contract {
+  abi;
+  address;
+  providerOrAccount;
+  deployTransactionHash;
+  structs;
+  events;
+  functions;
+  callStatic;
+  populateTransaction;
+  estimateFee;
+  callData;
+  /**
+   * 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, address, providerOrAccount = _provider.defaultProvider) {
+    this.address = address && address.toLowerCase();
+    this.providerOrAccount = providerOrAccount;
+    this.callData = new _calldata.CallData(abi);
+    this.structs = _calldata.CallData.getAbiStruct(abi);
+    this.events = (0, _index.getAbiEvents)(abi);
+    const parser = (0, _parser.createAbiParser)(abi);
+    this.abi = parser.getLegacyFormat();
+    const options = {
+      enumerable: true,
+      value: {},
+      writable: false
+    };
+    Object.defineProperties(this, {
+      functions: {
+        enumerable: true,
+        value: {},
+        writable: false
+      },
+      callStatic: {
+        enumerable: true,
+        value: {},
+        writable: false
+      },
+      populateTransaction: {
+        enumerable: true,
+        value: {},
+        writable: false
+      },
+      estimateFee: {
+        enumerable: true,
+        value: {},
+        writable: false
+      }
+    });
+    this.abi.forEach(abiElement => {
+      if (abiElement.type !== "function") return;
+      const signature = abiElement.name;
+      if (!this[signature]) {
+        Object.defineProperty(this, signature, {
+          ...options,
+          value: buildDefault(this, abiElement)
+        });
+      }
+      if (!this.functions[signature]) {
+        Object.defineProperty(this.functions, signature, {
+          ...options,
+          value: buildDefault(this, abiElement)
+        });
+      }
+      if (!this.callStatic[signature]) {
+        Object.defineProperty(this.callStatic, signature, {
+          ...options,
+          value: buildCall(this, abiElement)
+        });
+      }
+      if (!this.populateTransaction[signature]) {
+        Object.defineProperty(this.populateTransaction, signature, {
+          ...options,
+          value: buildPopulate(this, abiElement)
+        });
+      }
+      if (!this.estimateFee[signature]) {
+        Object.defineProperty(this.estimateFee, signature, {
+          ...options,
+          value: buildEstimate(this, abiElement)
+        });
+      }
+    });
+  }
+  attach(address) {
+    this.address = address;
+  }
+  connect(providerOrAccount) {
+    this.providerOrAccount = providerOrAccount;
+  }
+  async deployed() {
+    if (this.deployTransactionHash) {
+      await this.providerOrAccount.waitForTransaction(this.deployTransactionHash);
+      this.deployTransactionHash = void 0;
+    }
+    return this;
+  }
+  async call(method, args = [], {
+    parseRequest = true,
+    parseResponse = true,
+    formatResponse = void 0,
+    blockIdentifier = void 0
+  } = {}) {
+    (0, _assert.default)(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate(_types.ValidateType.CALL, method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Call skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
+    return this.providerOrAccount.callContract({
+      contractAddress: this.address,
+      calldata,
+      entrypoint: method
+    }, blockIdentifier).then(it => {
+      if (!parseResponse) {
+        return it;
+      }
+      if (formatResponse) {
+        return this.callData.format(method, it, formatResponse);
+      }
+      return this.callData.parse(method, it);
+    });
+  }
+  invoke(method, args = [], {
+    parseRequest = true,
+    maxFee,
+    nonce,
+    signature
+  } = {}) {
+    (0, _assert.default)(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate(_types.ValidateType.INVOKE, method, args);
+        return this.callData.compile(method, args);
+      }
+      console.warn("Invoke skipped parsing but provided rawArgs, possible malfunction request");
+      return args;
+    });
+    const invocation = {
+      contractAddress: this.address,
+      calldata,
+      entrypoint: method
+    };
+    if ("execute" in this.providerOrAccount) {
+      return this.providerOrAccount.execute(invocation, void 0, {
+        maxFee,
+        nonce
+      });
+    }
+    if (!nonce) throw new Error(`Nonce is required when invoking a function without an account`);
+    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
+    return this.providerOrAccount.invokeFunction({
+      ...invocation,
+      signature
+    }, {
+      nonce
+    });
+  }
+  async estimate(method, args = []) {
+    (0, _assert.default)(this.address !== null, "contract is not connected to an address");
+    if (!getCalldata(args, () => false)) {
+      this.callData.validate(_types.ValidateType.INVOKE, method, args);
+    }
+    const invocation = this.populate(method, args);
+    if ("estimateInvokeFee" in this.providerOrAccount) {
+      return this.providerOrAccount.estimateInvokeFee(invocation);
+    }
+    throw Error("Contract must be connected to the account contract to estimate");
+  }
+  populate(method, args = []) {
+    const calldata = getCalldata(args, () => this.callData.compile(method, args));
+    return {
+      contractAddress: this.address,
+      entrypoint: method,
+      calldata
+    };
+  }
+  parseEvents(receipt) {
+    return (0, _index.parseEvents)(receipt.events?.filter(event => (0, _num.cleanHex)(event.from_address) === (0, _num.cleanHex)(this.address), []) || [], this.events, this.structs, _calldata.CallData.getAbiEnum(this.abi));
+  }
+  isCairo1() {
+    return _calldata.cairo.isCairo1Abi(this.abi);
+  }
+  async getVersion() {
+    return this.providerOrAccount.getContractVersion(this.address);
+  }
+  typedv2(tAbi) {
+    return this;
+  }
+}
+exports.Contract = Contract;

package/dist/contract/default.d.ts

@@ -0,0 +1,58 @@
+import type { Abi as AbiKanabi, TypedContract as AbiWanTypedContract } from 'abi-wan-kanabi';
+import { AccountInterface } from '../account';
+import { ProviderInterface } from '../provider';
+import { Abi, AbiEvents, ArgsOrCalldata, ArgsOrCalldataWithOptions, AsyncContractFunction, Call, CallOptions, Calldata, ContractFunction, ContractOptions, EstimateFeeResponse, InvokeFunctionResponse, InvokeOptions, ParsedEvents, RawArgs, Result, AbiStruct } from '../types';
+import { ContractInterface } from './interface';
+import type { GetTransactionReceiptResponse } from '../utils/transactionReceipt';
+export type TypedContractV2<TAbi extends AbiKanabi> = AbiWanTypedContract<TAbi> & Contract;
+export declare const splitArgsAndOptions: (args: ArgsOrCalldataWithOptions) => {
+    args: ArgsOrCalldata;
+    options: ContractOptions;
+} | {
+    args: ArgsOrCalldata;
+    options?: undefined;
+};
+export declare function getCalldata(args: RawArgs, callback: Function): Calldata;
+export declare class Contract implements ContractInterface {
+    abi: Abi;
+    address: string;
+    providerOrAccount: ProviderInterface | AccountInterface;
+    deployTransactionHash?: string;
+    protected readonly structs: {
+        [name: string]: AbiStruct;
+    };
+    protected readonly events: AbiEvents;
+    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;
+    private callData;
+    /**
+     * 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);
+    attach(address: string): void;
+    connect(providerOrAccount: ProviderInterface | AccountInterface): void;
+    deployed(): Promise<Contract>;
+    call(method: string, args?: ArgsOrCalldata, { parseRequest, parseResponse, formatResponse, blockIdentifier, }?: CallOptions): Promise<Result>;
+    invoke(method: string, args?: ArgsOrCalldata, { parseRequest, maxFee, nonce, signature }?: InvokeOptions): Promise<InvokeFunctionResponse>;
+    estimate(method: string, args?: ArgsOrCalldata): Promise<EstimateFeeResponse>;
+    populate(method: string, args?: RawArgs): Call;
+    parseEvents(receipt: GetTransactionReceiptResponse): ParsedEvents;
+    isCairo1(): boolean;
+    getVersion(): Promise<import("../types").ContractVersion>;
+    typedv2<TAbi extends AbiKanabi>(tAbi: TAbi): TypedContractV2<TAbi>;
+}