starknet 6.9.0 → 6.10.1

package/dist/contract/default.mjs

@@ -0,0 +1,254 @@
+import { defaultProvider } from "../provider/index.mjs";
+import {
+  ValidateType
+} from "../types/index.mjs";
+import assert from "../utils/assert.mjs";
+import { CallData, cairo } from "../utils/calldata/index.mjs";
+import { createAbiParser } from "../utils/calldata/parser/index.mjs";
+import { getAbiEvents, parseEvents as parseRawEvents } from "../utils/events/index.mjs";
+import { cleanHex } from "../utils/num.mjs";
+export 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 };
+};
+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);
+  };
+}
+export 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();
+}
+export 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 = defaultProvider) {
+    this.address = address && address.toLowerCase();
+    this.providerOrAccount = providerOrAccount;
+    this.callData = new CallData(abi);
+    this.structs = CallData.getAbiStruct(abi);
+    this.events = getAbiEvents(abi);
+    const 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
+  } = {}) {
+    assert(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate(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 } = {}) {
+    assert(this.address !== null, "contract is not connected to an address");
+    const calldata = getCalldata(args, () => {
+      if (parseRequest) {
+        this.callData.validate(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 = []) {
+    assert(this.address !== null, "contract is not connected to an address");
+    if (!getCalldata(args, () => false)) {
+      this.callData.validate(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 parseRawEvents(
+      receipt.events?.filter(
+        (event) => cleanHex(event.from_address) === cleanHex(this.address),
+        []
+      ) || [],
+      this.events,
+      this.structs,
+      CallData.getAbiEnum(this.abi)
+    );
+  }
+  isCairo1() {
+    return cairo.isCairo1Abi(this.abi);
+  }
+  async getVersion() {
+    return this.providerOrAccount.getContractVersion(this.address);
+  }
+  typedv2(tAbi) {
+    return this;
+  }
+}

package/dist/contract/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _default = require("./default.cjs");
+Object.keys(_default).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _default[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _default[key];
+    }
+  });
+});
+var _interface = require("./interface.cjs");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interface[key];
+    }
+  });
+});
+var _contractFactory = require("./contractFactory.cjs");
+Object.keys(_contractFactory).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _contractFactory[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _contractFactory[key];
+    }
+  });
+});

package/dist/contract/index.d.ts

@@ -0,0 +1,3 @@
+export * from './default';
+export * from './interface';
+export * from './contractFactory';

package/dist/contract/index.mjs

@@ -0,0 +1,3 @@
+export * from "./default.mjs";
+export * from "./interface.mjs";
+export * from "./contractFactory.mjs";

package/dist/contract/interface.cjs

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContractInterface = void 0;
+class ContractInterface {
+  functions;
+  callStatic;
+  populateTransaction;
+  estimateFee;
+}
+exports.ContractInterface = ContractInterface;

package/dist/contract/interface.d.ts

@@ -0,0 +1,128 @@
+import type { Abi as AbiKanabi, TypedContract as AbiWanTypedContract } from 'abi-wan-kanabi';
+import { AccountInterface } from '../account';
+import { ProviderInterface } from '../provider';
+import { Abi, ArgsOrCalldata, AsyncContractFunction, BigNumberish, BlockIdentifier, CallOptions, Calldata, ContractFunction, ContractVersion, EstimateFeeResponse, Invocation, InvokeFunctionResponse, InvokeOptions, ParsedEvents, RawArgs, Result, Uint256 } from '../types';
+import { CairoCustomEnum } from '../utils/calldata/enum/CairoCustomEnum';
+import { CairoOption } from '../utils/calldata/enum/CairoOption';
+import { CairoResult } from '../utils/calldata/enum/CairoResult';
+import type { GetTransactionReceiptResponse } from '../utils/transactionReceipt';
+declare module 'abi-wan-kanabi' {
+    interface Config<OptionT = any, ResultT = any, ErrorT = any> {
+        FeltType: BigNumberish;
+        U256Type: number | bigint | Uint256;
+        U512Type: BigNumberish;
+        Secp256k1PointType: BigNumberish;
+        Option: CairoOption<OptionT>;
+        Tuple: Record<number, BigNumberish | object | boolean>;
+        Result: CairoResult<ResultT, ErrorT>;
+        Enum: CairoCustomEnum;
+        Calldata: RawArgs | Calldata;
+        CallOptions: CallOptions;
+        InvokeOptions: InvokeOptions;
+        InvokeFunctionResponse: InvokeFunctionResponse;
+    }
+}
+type TypedContractV2<TAbi extends AbiKanabi> = AbiWanTypedContract<TAbi> & ContractInterface;
+export declare abstract class ContractInterface {
+    abstract abi: Abi;
+    abstract address: string;
+    abstract providerOrAccount: ProviderInterface | AccountInterface;
+    abstract deployTransactionHash?: string;
+    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;
+    /**
+     * Saves the address of the contract deployed on network that will be used for interaction
+     *
+     * @param address - address of the contract
+     */
+    abstract attach(address: string): void;
+    /**
+     * Attaches to new Provider or Account
+     *
+     * @param providerOrAccount - new Provider or Account to attach to
+     */
+    abstract 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
+     */
+    abstract deployed(): Promise<ContractInterface>;
+    /**
+     * Calls a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call
+     * @param options optional blockIdentifier
+     * @returns Result of the call as an array with key value pars
+     */
+    abstract call(method: string, args?: ArgsOrCalldata, options?: CallOptions): Promise<Result>;
+    /**
+     * Invokes a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the invoke or Calldata
+     * @param options
+     * @returns Add Transaction Response
+     */
+    abstract invoke(method: string, args?: ArgsOrCalldata, options?: InvokeOptions): Promise<InvokeFunctionResponse>;
+    /**
+     * Estimates a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call or Calldata
+     * @param options optional blockIdentifier
+     */
+    abstract estimate(method: string, args?: ArgsOrCalldata, options?: {
+        blockIdentifier?: BlockIdentifier;
+    }): Promise<EstimateFeeResponse>;
+    /**
+     * Calls a method on a contract
+     *
+     * @param method name of the method
+     * @param args Array of the arguments for the call or Calldata
+     * @returns Invocation object
+     */
+    abstract populate(method: string, args?: ArgsOrCalldata): Invocation;
+    /**
+     * Parse contract events of a GetTransactionReceiptResponse received from waitForTransaction. Based on contract's abi
+     *
+     * @param receipt transaction receipt
+     * @returns Events parsed
+     */
+    abstract parseEvents(receipt: GetTransactionReceiptResponse): ParsedEvents;
+    /**
+     * tells if the contract comes from a Cairo 1 contract
+     *
+     * @returns TRUE if the contract comes from a Cairo1 contract
+     * @example
+     * ```typescript
+     * const isCairo1: boolean = myContract.isCairo1();
+     * ```
+     */
+    abstract isCairo1(): boolean;
+    /**
+     * Retrieves the version of the contract (cairo version & compiler version)
+     */
+    abstract getVersion(): Promise<ContractVersion>;
+    /**
+     * Returns a typed instance of ContractV2 based on the supplied ABI.
+     *
+     * @param {TAbi} tAbi - The ABI (Abstract Binary Interface) of the ContractV2.
+     * @return {TypedContractV2<TAbi>} - A typed instance of ContractV2.
+     */
+    abstract typedv2<TAbi extends AbiKanabi>(tAbi: TAbi): TypedContractV2<TAbi>;
+}
+export {};

package/dist/contract/interface.mjs

@@ -0,0 +1,6 @@
+export class ContractInterface {
+  functions;
+  callStatic;
+  populateTransaction;
+  estimateFee;
+}