starknet 6.9.0 → 6.10.1

package/dist/account/default.mjs

@@ -0,0 +1,652 @@
+import { UDC, ZERO } from "../constants.mjs";
+import { Provider } from "../provider/index.mjs";
+import { Signer } from "../signer/index.mjs";
+import {
+  TransactionType
+} from "../types/index.mjs";
+import { ETransactionVersion, ETransactionVersion3 } from "../types/api/index.mjs";
+import { CallData } from "../utils/calldata/index.mjs";
+import { extractContractHashes, isSierra } from "../utils/contract.mjs";
+import { parseUDCEvent } from "../utils/events/index.mjs";
+import { calculateContractAddressFromHash } from "../utils/hash/index.mjs";
+import { toBigInt, toCairoBool } from "../utils/num.mjs";
+import { parseContract } from "../utils/provider.mjs";
+import { isString } from "../utils/shortString.mjs";
+import {
+  estimateFeeToBounds,
+  formatSignature,
+  reduceV2,
+  toFeeVersion,
+  toTransactionVersion,
+  v3Details
+} from "../utils/stark.mjs";
+import { buildUDCCall, getExecuteCalldata } from "../utils/transaction.mjs";
+import { getMessageHash } from "../utils/typedData.mjs";
+export class Account extends Provider {
+  signer;
+  address;
+  cairoVersion;
+  transactionVersion;
+  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = ETransactionVersion.V2) {
+    super(providerOrOptions);
+    this.address = address.toLowerCase();
+    this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
+    if (cairoVersion) {
+      this.cairoVersion = cairoVersion.toString();
+    }
+    this.transactionVersion = transactionVersion;
+  }
+  // provided version or contract based preferred transactionVersion
+  getPreferredVersion(type12, type3) {
+    if (this.transactionVersion === ETransactionVersion.V3) return type3;
+    if (this.transactionVersion === ETransactionVersion.V2) return type12;
+    return ETransactionVersion.V3;
+  }
+  async getNonce(blockIdentifier) {
+    return super.getNonceForAddress(this.address, blockIdentifier);
+  }
+  async getNonceSafe(nonce) {
+    try {
+      return toBigInt(nonce ?? await this.getNonce());
+    } catch (error) {
+      return 0n;
+    }
+  }
+  /**
+   * Retrieves the Cairo version from the network and sets `cairoVersion` if not already set in the constructor.
+   * @param classHash if provided detects Cairo version from classHash, otherwise from the account address
+   */
+  async getCairoVersion(classHash) {
+    if (!this.cairoVersion) {
+      const { cairo } = classHash ? await super.getContractVersion(void 0, classHash) : await super.getContractVersion(this.address);
+      this.cairoVersion = cairo;
+    }
+    return this.cairoVersion;
+  }
+  async estimateFee(calls, estimateFeeDetails = {}) {
+    return this.estimateInvokeFee(calls, estimateFeeDetails);
+  }
+  async estimateInvokeFee(calls, details = {}) {
+    const {
+      nonce: providedNonce,
+      blockIdentifier,
+      version: providedVersion,
+      skipValidate = true
+    } = details;
+    const transactions = Array.isArray(calls) ? calls : [calls];
+    const nonce = toBigInt(providedNonce ?? await this.getNonce());
+    const version = toTransactionVersion(
+      this.getPreferredVersion(ETransactionVersion.F1, ETransactionVersion.F3),
+      toFeeVersion(providedVersion)
+    );
+    const chainId = await this.getChainId();
+    const signerDetails = {
+      ...v3Details(details),
+      walletAddress: this.address,
+      nonce,
+      maxFee: ZERO,
+      version,
+      chainId,
+      cairoVersion: await this.getCairoVersion(),
+      skipValidate
+    };
+    const invocation = await this.buildInvocation(transactions, signerDetails);
+    return super.getInvokeEstimateFee(
+      { ...invocation },
+      { ...v3Details(details), version, nonce },
+      blockIdentifier,
+      details.skipValidate
+    );
+  }
+  async estimateDeclareFee(payload, details = {}) {
+    const {
+      blockIdentifier,
+      nonce: providedNonce,
+      version: providedVersion,
+      skipValidate = true
+    } = details;
+    const nonce = toBigInt(providedNonce ?? await this.getNonce());
+    const version = toTransactionVersion(
+      !isSierra(payload.contract) ? ETransactionVersion.F1 : this.getPreferredVersion(ETransactionVersion.F2, ETransactionVersion.F3),
+      toFeeVersion(providedVersion)
+    );
+    const chainId = await this.getChainId();
+    const declareContractTransaction = await this.buildDeclarePayload(payload, {
+      ...v3Details(details),
+      nonce,
+      chainId,
+      version,
+      walletAddress: this.address,
+      maxFee: ZERO,
+      cairoVersion: void 0,
+      // unused parameter
+      skipValidate
+    });
+    return super.getDeclareEstimateFee(
+      declareContractTransaction,
+      { ...v3Details(details), version, nonce },
+      blockIdentifier,
+      details.skipValidate
+    );
+  }
+  async estimateAccountDeployFee({
+    classHash,
+    addressSalt = 0,
+    constructorCalldata = [],
+    contractAddress
+  }, details = {}) {
+    const { blockIdentifier, version: providedVersion, skipValidate = true } = details;
+    const version = toTransactionVersion(
+      this.getPreferredVersion(ETransactionVersion.F1, ETransactionVersion.F3),
+      toFeeVersion(providedVersion)
+    );
+    const nonce = ZERO;
+    const chainId = await this.getChainId();
+    const payload = await this.buildAccountDeployPayload(
+      { classHash, addressSalt, constructorCalldata, contractAddress },
+      {
+        ...v3Details(details),
+        nonce,
+        chainId,
+        version,
+        walletAddress: this.address,
+        // unused parameter
+        maxFee: ZERO,
+        cairoVersion: void 0,
+        // unused parameter,
+        skipValidate
+      }
+    );
+    return super.getDeployAccountEstimateFee(
+      { ...payload },
+      { ...v3Details(details), version, nonce },
+      blockIdentifier,
+      details.skipValidate
+    );
+  }
+  async estimateDeployFee(payload, details = {}) {
+    const calls = this.buildUDCContractPayload(payload);
+    return this.estimateInvokeFee(calls, details);
+  }
+  async estimateFeeBulk(invocations, details = {}) {
+    const { nonce, blockIdentifier, version, skipValidate } = details;
+    const accountInvocations = await this.accountInvocationsFactory(invocations, {
+      ...v3Details(details),
+      versions: [
+        ETransactionVersion.F1,
+        // non-sierra
+        toTransactionVersion(
+          this.getPreferredVersion(ETransactionVersion.F2, ETransactionVersion.F3),
+          version
+        )
+        // sierra
+      ],
+      nonce,
+      blockIdentifier,
+      skipValidate
+    });
+    return super.getEstimateFeeBulk(accountInvocations, {
+      blockIdentifier,
+      skipValidate
+    });
+  }
+  async simulateTransaction(invocations, details = {}) {
+    const { nonce, blockIdentifier, skipValidate = true, skipExecute, version } = details;
+    const accountInvocations = await this.accountInvocationsFactory(invocations, {
+      ...v3Details(details),
+      versions: [
+        ETransactionVersion.V1,
+        // non-sierra
+        toTransactionVersion(
+          this.getPreferredVersion(ETransactionVersion.V2, ETransactionVersion.V3),
+          version
+        )
+      ],
+      nonce,
+      blockIdentifier,
+      skipValidate
+    });
+    return super.getSimulateTransaction(accountInvocations, {
+      blockIdentifier,
+      skipValidate,
+      skipExecute
+    });
+  }
+  async execute(transactions, arg2, transactionsDetail = {}) {
+    const details = arg2 === void 0 || Array.isArray(arg2) ? transactionsDetail : arg2;
+    const calls = Array.isArray(transactions) ? transactions : [transactions];
+    const nonce = toBigInt(details.nonce ?? await this.getNonce());
+    const version = toTransactionVersion(
+      this.getPreferredVersion(ETransactionVersion.V1, ETransactionVersion.V3),
+      // TODO: does this depend on cairo version ?
+      details.version
+    );
+    const estimate = await this.getUniversalSuggestedFee(
+      version,
+      { type: TransactionType.INVOKE, payload: transactions },
+      {
+        ...details,
+        version
+      }
+    );
+    const chainId = await this.getChainId();
+    const signerDetails = {
+      ...v3Details(details),
+      resourceBounds: estimate.resourceBounds,
+      walletAddress: this.address,
+      nonce,
+      maxFee: estimate.maxFee,
+      version,
+      chainId,
+      cairoVersion: await this.getCairoVersion()
+    };
+    const signature = await this.signer.signTransaction(calls, signerDetails);
+    const calldata = getExecuteCalldata(calls, await this.getCairoVersion());
+    return this.invokeFunction(
+      { contractAddress: this.address, calldata, signature },
+      {
+        ...v3Details(details),
+        resourceBounds: estimate.resourceBounds,
+        nonce,
+        maxFee: estimate.maxFee,
+        version
+      }
+    );
+  }
+  /**
+   * First check if contract is already declared, if not declare it
+   * If contract already declared returned transaction_hash is ''.
+   * Method will pass even if contract is already declared
+   * @param transactionsDetail (optional)
+   */
+  async declareIfNot(payload, transactionsDetail = {}) {
+    const declareContractPayload = extractContractHashes(payload);
+    try {
+      await this.getClassByHash(declareContractPayload.classHash);
+    } catch (error) {
+      return this.declare(payload, transactionsDetail);
+    }
+    return {
+      transaction_hash: "",
+      class_hash: declareContractPayload.classHash
+    };
+  }
+  async declare(payload, details = {}) {
+    const declareContractPayload = extractContractHashes(payload);
+    const { nonce, version: providedVersion } = details;
+    const version = toTransactionVersion(
+      !isSierra(payload.contract) ? ETransactionVersion.V1 : this.getPreferredVersion(ETransactionVersion.V2, ETransactionVersion.V3),
+      providedVersion
+    );
+    const estimate = await this.getUniversalSuggestedFee(
+      version,
+      {
+        type: TransactionType.DECLARE,
+        payload: declareContractPayload
+      },
+      {
+        ...details,
+        version
+      }
+    );
+    const declareDetails = {
+      ...v3Details(details),
+      resourceBounds: estimate.resourceBounds,
+      maxFee: estimate.maxFee,
+      nonce: toBigInt(nonce ?? await this.getNonce()),
+      version,
+      chainId: await this.getChainId(),
+      walletAddress: this.address,
+      cairoVersion: void 0
+    };
+    const declareContractTransaction = await this.buildDeclarePayload(
+      declareContractPayload,
+      declareDetails
+    );
+    return this.declareContract(declareContractTransaction, declareDetails);
+  }
+  async deploy(payload, details = {}) {
+    const { calls, addresses } = buildUDCCall(payload, this.address);
+    const invokeResponse = await this.execute(calls, void 0, details);
+    return {
+      ...invokeResponse,
+      contract_address: addresses
+    };
+  }
+  async deployContract(payload, details = {}) {
+    const deployTx = await this.deploy(payload, details);
+    const txReceipt = await this.waitForTransaction(deployTx.transaction_hash);
+    return parseUDCEvent(txReceipt);
+  }
+  async declareAndDeploy(payload, details = {}) {
+    const { constructorCalldata, salt, unique } = payload;
+    let declare = await this.declareIfNot(payload, details);
+    if (declare.transaction_hash !== "") {
+      const tx = await this.waitForTransaction(declare.transaction_hash);
+      declare = { ...declare, ...tx };
+    }
+    const deploy = await this.deployContract(
+      { classHash: declare.class_hash, salt, unique, constructorCalldata },
+      details
+    );
+    return { declare: { ...declare }, deploy };
+  }
+  deploySelf = this.deployAccount;
+  async deployAccount({
+    classHash,
+    constructorCalldata = [],
+    addressSalt = 0,
+    contractAddress: providedContractAddress
+  }, details = {}) {
+    const version = toTransactionVersion(
+      this.getPreferredVersion(ETransactionVersion.V1, ETransactionVersion.V3),
+      details.version
+    );
+    const nonce = ZERO;
+    const chainId = await this.getChainId();
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
+    const estimate = await this.getUniversalSuggestedFee(
+      version,
+      {
+        type: TransactionType.DEPLOY_ACCOUNT,
+        payload: {
+          classHash,
+          constructorCalldata: compiledCalldata,
+          addressSalt,
+          contractAddress
+        }
+      },
+      details
+    );
+    const signature = await this.signer.signDeployAccountTransaction({
+      ...v3Details(details),
+      classHash,
+      constructorCalldata: compiledCalldata,
+      contractAddress,
+      addressSalt,
+      chainId,
+      resourceBounds: estimate.resourceBounds,
+      maxFee: estimate.maxFee,
+      version,
+      nonce
+    });
+    return this.deployAccountContract(
+      { classHash, addressSalt, constructorCalldata, signature },
+      {
+        ...v3Details(details),
+        nonce,
+        resourceBounds: estimate.resourceBounds,
+        maxFee: estimate.maxFee,
+        version
+      }
+    );
+  }
+  async signMessage(typedData) {
+    return this.signer.signMessage(typedData, this.address);
+  }
+  async hashMessage(typedData) {
+    return getMessageHash(typedData, this.address);
+  }
+  async verifyMessageHash(hash, signature, signatureVerificationFunctionName, signatureVerificationResponse) {
+    const knownSigVerificationFName = signatureVerificationFunctionName ? [signatureVerificationFunctionName] : ["isValidSignature", "is_valid_signature"];
+    const knownSignatureResponse = signatureVerificationResponse || {
+      okResponse: [
+        // any non-nok response is true
+      ],
+      nokResponse: [
+        "0x0",
+        // Devnet
+        "0x00"
+        // OpenZeppelin 0.7.0 to 0.9.0 invalid signature
+      ],
+      error: [
+        "argent/invalid-signature",
+        // ArgentX 0.3.0 to 0.3.1
+        "is invalid, with respect to the public key",
+        // OpenZeppelin until 0.6.1, Braavos 0.0.11
+        "INVALID_SIG"
+        // Braavos 1.0.0
+      ]
+    };
+    let error;
+    for (const SigVerificationFName of knownSigVerificationFName) {
+      try {
+        const resp = await this.callContract({
+          contractAddress: this.address,
+          entrypoint: SigVerificationFName,
+          calldata: CallData.compile({
+            hash: toBigInt(hash).toString(),
+            signature: formatSignature(signature)
+          })
+        });
+        if (knownSignatureResponse.nokResponse.includes(resp[0].toString())) {
+          return false;
+        }
+        if (knownSignatureResponse.okResponse.length === 0 || knownSignatureResponse.okResponse.includes(resp[0].toString())) {
+          return true;
+        }
+        throw Error("signatureVerificationResponse Error: response is not part of known responses");
+      } catch (err) {
+        if (knownSignatureResponse.error.some(
+          (errMessage) => err.message.includes(errMessage)
+        )) {
+          return false;
+        }
+        error = err;
+      }
+    }
+    throw Error(`Signature verification Error: ${error}`);
+  }
+  async verifyMessage(typedData, signature, signatureVerificationFunctionName, signatureVerificationResponse) {
+    const hash = await this.hashMessage(typedData);
+    return this.verifyMessageHash(
+      hash,
+      signature,
+      signatureVerificationFunctionName,
+      signatureVerificationResponse
+    );
+  }
+  /*
+   * Support methods
+   */
+  async getUniversalSuggestedFee(version, { type, payload }, details) {
+    let maxFee = 0;
+    let resourceBounds = estimateFeeToBounds(ZERO);
+    if (version === ETransactionVersion.V3) {
+      resourceBounds = details.resourceBounds ?? (await this.getSuggestedFee({ type, payload }, details)).resourceBounds;
+    } else {
+      maxFee = details.maxFee ?? (await this.getSuggestedFee({ type, payload }, details)).suggestedMaxFee;
+    }
+    return {
+      maxFee,
+      resourceBounds
+    };
+  }
+  async getSuggestedFee({ type, payload }, details) {
+    let feeEstimate;
+    switch (type) {
+      case TransactionType.INVOKE:
+        feeEstimate = await this.estimateInvokeFee(payload, details);
+        break;
+      case TransactionType.DECLARE:
+        feeEstimate = await this.estimateDeclareFee(payload, details);
+        break;
+      case TransactionType.DEPLOY_ACCOUNT:
+        feeEstimate = await this.estimateAccountDeployFee(payload, details);
+        break;
+      case TransactionType.DEPLOY:
+        feeEstimate = await this.estimateDeployFee(payload, details);
+        break;
+      default:
+        feeEstimate = {
+          gas_consumed: 0n,
+          gas_price: 0n,
+          overall_fee: ZERO,
+          unit: "FRI",
+          suggestedMaxFee: ZERO,
+          resourceBounds: estimateFeeToBounds(ZERO),
+          data_gas_consumed: 0n,
+          data_gas_price: 0n
+        };
+        break;
+    }
+    return feeEstimate;
+  }
+  async buildInvocation(call, details) {
+    const calldata = getExecuteCalldata(call, await this.getCairoVersion());
+    const signature = !details.skipValidate ? await this.signer.signTransaction(call, details) : [];
+    return {
+      ...v3Details(details),
+      contractAddress: this.address,
+      calldata,
+      signature
+    };
+  }
+  async buildDeclarePayload(payload, details) {
+    const { classHash, contract, compiledClassHash } = extractContractHashes(payload);
+    const compressedCompiledContract = parseContract(contract);
+    if (typeof compiledClassHash === "undefined" && (details.version === ETransactionVersion3.F3 || details.version === ETransactionVersion3.V3)) {
+      throw Error("V3 Transaction work with Cairo1 Contracts and require compiledClassHash");
+    }
+    const signature = !details.skipValidate ? await this.signer.signDeclareTransaction({
+      ...details,
+      ...v3Details(details),
+      classHash,
+      compiledClassHash,
+      // TODO: TS, cast because optional for v2 and required for v3, thrown if not present
+      senderAddress: details.walletAddress
+    }) : [];
+    return {
+      senderAddress: details.walletAddress,
+      signature,
+      contract: compressedCompiledContract,
+      compiledClassHash
+    };
+  }
+  async buildAccountDeployPayload({
+    classHash,
+    addressSalt = 0,
+    constructorCalldata = [],
+    contractAddress: providedContractAddress
+  }, details) {
+    const compiledCalldata = CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? calculateContractAddressFromHash(addressSalt, classHash, compiledCalldata, 0);
+    const signature = !details.skipValidate ? await this.signer.signDeployAccountTransaction({
+      ...details,
+      ...v3Details(details),
+      classHash,
+      contractAddress,
+      addressSalt,
+      constructorCalldata: compiledCalldata
+    }) : [];
+    return {
+      ...v3Details(details),
+      classHash,
+      addressSalt,
+      constructorCalldata: compiledCalldata,
+      signature
+    };
+  }
+  buildUDCContractPayload(payload) {
+    const calls = [].concat(payload).map((it) => {
+      const {
+        classHash,
+        salt = "0",
+        unique = true,
+        constructorCalldata = []
+      } = it;
+      const compiledConstructorCallData = CallData.compile(constructorCalldata);
+      return {
+        contractAddress: UDC.ADDRESS,
+        entrypoint: UDC.ENTRYPOINT,
+        calldata: [
+          classHash,
+          salt,
+          toCairoBool(unique),
+          compiledConstructorCallData.length,
+          ...compiledConstructorCallData
+        ]
+      };
+    });
+    return calls;
+  }
+  async accountInvocationsFactory(invocations, details) {
+    const { nonce, blockIdentifier, skipValidate = true } = details;
+    const safeNonce = await this.getNonceSafe(nonce);
+    const chainId = await this.getChainId();
+    const versions = details.versions.map((it) => toTransactionVersion(it));
+    const tx0Payload = "payload" in invocations[0] ? invocations[0].payload : invocations[0];
+    const cairoVersion = invocations[0].type === TransactionType.DEPLOY_ACCOUNT ? await this.getCairoVersion(tx0Payload.classHash) : await this.getCairoVersion();
+    return Promise.all(
+      [].concat(invocations).map(async (transaction, index) => {
+        const txPayload = "payload" in transaction ? transaction.payload : transaction;
+        const signerDetails = {
+          ...v3Details(details),
+          walletAddress: this.address,
+          nonce: toBigInt(Number(safeNonce) + index),
+          maxFee: ZERO,
+          chainId,
+          cairoVersion,
+          version: "",
+          skipValidate
+        };
+        const common = {
+          type: transaction.type,
+          nonce: toBigInt(Number(safeNonce) + index),
+          blockIdentifier,
+          version: ""
+        };
+        if (transaction.type === TransactionType.INVOKE) {
+          const versionX = reduceV2(versions[1]);
+          signerDetails.version = versionX;
+          common.version = versionX;
+          const payload = await this.buildInvocation(
+            [].concat(txPayload),
+            signerDetails
+          );
+          return {
+            ...common,
+            ...payload
+          };
+        }
+        if (transaction.type === TransactionType.DEPLOY) {
+          const versionX = reduceV2(versions[1]);
+          signerDetails.version = versionX;
+          common.version = versionX;
+          const calls = this.buildUDCContractPayload(txPayload);
+          const payload = await this.buildInvocation(calls, signerDetails);
+          return {
+            ...common,
+            ...payload,
+            type: TransactionType.INVOKE
+          };
+        }
+        if (transaction.type === TransactionType.DECLARE) {
+          const versionX = !isSierra(txPayload.contract) ? versions[0] : versions[1];
+          signerDetails.version = versionX;
+          common.version = versionX;
+          const payload = await this.buildDeclarePayload(txPayload, signerDetails);
+          return {
+            ...common,
+            ...payload
+          };
+        }
+        if (transaction.type === TransactionType.DEPLOY_ACCOUNT) {
+          const versionX = reduceV2(versions[1]);
+          signerDetails.version = versionX;
+          common.version = versionX;
+          const payload = await this.buildAccountDeployPayload(txPayload, signerDetails);
+          return {
+            ...common,
+            ...payload
+          };
+        }
+        throw Error(`accountInvocationsFactory: unsupported transaction type: ${transaction}`);
+      })
+    );
+  }
+  async getStarkName(address = this.address, StarknetIdContract) {
+    return super.getStarkName(address, StarknetIdContract);
+  }
+}

package/dist/account/index.cjs

@@ -0,0 +1,27 @@
+"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];
+    }
+  });
+});

package/dist/account/index.d.ts

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

package/dist/account/index.mjs

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

package/dist/account/interface.cjs

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AccountInterface = void 0;
+var _provider = require("../provider/index.cjs");
+class AccountInterface extends _provider.ProviderInterface {}
+exports.AccountInterface = AccountInterface;