starknet 6.9.0 → 6.10.1

package/dist/account/default.cjs

@@ -0,0 +1,655 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Account = void 0;
+var _constants = require("../constants.cjs");
+var _provider = require("../provider/index.cjs");
+var _signer = require("../signer/index.cjs");
+var _types = require("../types/index.cjs");
+var _api = require("../types/api/index.cjs");
+var _calldata = require("../utils/calldata/index.cjs");
+var _contract = require("../utils/contract.cjs");
+var _events = require("../utils/events/index.cjs");
+var _hash = require("../utils/hash/index.cjs");
+var _num = require("../utils/num.cjs");
+var _provider2 = require("../utils/provider.cjs");
+var _shortString = require("../utils/shortString.cjs");
+var _stark = require("../utils/stark.cjs");
+var _transaction = require("../utils/transaction.cjs");
+var _typedData = require("../utils/typedData.cjs");
+class Account extends _provider.Provider {
+  signer;
+  address;
+  cairoVersion;
+  transactionVersion;
+  constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = _api.ETransactionVersion.V2) {
+    super(providerOrOptions);
+    this.address = address.toLowerCase();
+    this.signer = (0, _shortString.isString)(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new _signer.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 === _api.ETransactionVersion.V3) return type3;
+    if (this.transactionVersion === _api.ETransactionVersion.V2) return type12;
+    return _api.ETransactionVersion.V3;
+  }
+  async getNonce(blockIdentifier) {
+    return super.getNonceForAddress(this.address, blockIdentifier);
+  }
+  async getNonceSafe(nonce) {
+    try {
+      return (0, _num.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 = (0, _num.toBigInt)(providedNonce ?? (await this.getNonce()));
+    const version = (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.F1, _api.ETransactionVersion.F3), (0, _stark.toFeeVersion)(providedVersion));
+    const chainId = await this.getChainId();
+    const signerDetails = {
+      ...(0, _stark.v3Details)(details),
+      walletAddress: this.address,
+      nonce,
+      maxFee: _constants.ZERO,
+      version,
+      chainId,
+      cairoVersion: await this.getCairoVersion(),
+      skipValidate
+    };
+    const invocation = await this.buildInvocation(transactions, signerDetails);
+    return super.getInvokeEstimateFee({
+      ...invocation
+    }, {
+      ...(0, _stark.v3Details)(details),
+      version,
+      nonce
+    }, blockIdentifier, details.skipValidate);
+  }
+  async estimateDeclareFee(payload, details = {}) {
+    const {
+      blockIdentifier,
+      nonce: providedNonce,
+      version: providedVersion,
+      skipValidate = true
+    } = details;
+    const nonce = (0, _num.toBigInt)(providedNonce ?? (await this.getNonce()));
+    const version = (0, _stark.toTransactionVersion)(!(0, _contract.isSierra)(payload.contract) ? _api.ETransactionVersion.F1 : this.getPreferredVersion(_api.ETransactionVersion.F2, _api.ETransactionVersion.F3), (0, _stark.toFeeVersion)(providedVersion));
+    const chainId = await this.getChainId();
+    const declareContractTransaction = await this.buildDeclarePayload(payload, {
+      ...(0, _stark.v3Details)(details),
+      nonce,
+      chainId,
+      version,
+      walletAddress: this.address,
+      maxFee: _constants.ZERO,
+      cairoVersion: void 0,
+      // unused parameter
+      skipValidate
+    });
+    return super.getDeclareEstimateFee(declareContractTransaction, {
+      ...(0, _stark.v3Details)(details),
+      version,
+      nonce
+    }, blockIdentifier, details.skipValidate);
+  }
+  async estimateAccountDeployFee({
+    classHash,
+    addressSalt = 0,
+    constructorCalldata = [],
+    contractAddress
+  }, details = {}) {
+    const {
+      blockIdentifier,
+      version: providedVersion,
+      skipValidate = true
+    } = details;
+    const version = (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.F1, _api.ETransactionVersion.F3), (0, _stark.toFeeVersion)(providedVersion));
+    const nonce = _constants.ZERO;
+    const chainId = await this.getChainId();
+    const payload = await this.buildAccountDeployPayload({
+      classHash,
+      addressSalt,
+      constructorCalldata,
+      contractAddress
+    }, {
+      ...(0, _stark.v3Details)(details),
+      nonce,
+      chainId,
+      version,
+      walletAddress: this.address,
+      // unused parameter
+      maxFee: _constants.ZERO,
+      cairoVersion: void 0,
+      // unused parameter,
+      skipValidate
+    });
+    return super.getDeployAccountEstimateFee({
+      ...payload
+    }, {
+      ...(0, _stark.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, {
+      ...(0, _stark.v3Details)(details),
+      versions: [_api.ETransactionVersion.F1,
+      // non-sierra
+      (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.F2, _api.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, {
+      ...(0, _stark.v3Details)(details),
+      versions: [_api.ETransactionVersion.V1,
+      // non-sierra
+      (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.V2, _api.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 = (0, _num.toBigInt)(details.nonce ?? (await this.getNonce()));
+    const version = (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.V1, _api.ETransactionVersion.V3),
+    // TODO: does this depend on cairo version ?
+    details.version);
+    const estimate = await this.getUniversalSuggestedFee(version, {
+      type: _types.TransactionType.INVOKE,
+      payload: transactions
+    }, {
+      ...details,
+      version
+    });
+    const chainId = await this.getChainId();
+    const signerDetails = {
+      ...(0, _stark.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 = (0, _transaction.getExecuteCalldata)(calls, await this.getCairoVersion());
+    return this.invokeFunction({
+      contractAddress: this.address,
+      calldata,
+      signature
+    }, {
+      ...(0, _stark.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 = (0, _contract.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 = (0, _contract.extractContractHashes)(payload);
+    const {
+      nonce,
+      version: providedVersion
+    } = details;
+    const version = (0, _stark.toTransactionVersion)(!(0, _contract.isSierra)(payload.contract) ? _api.ETransactionVersion.V1 : this.getPreferredVersion(_api.ETransactionVersion.V2, _api.ETransactionVersion.V3), providedVersion);
+    const estimate = await this.getUniversalSuggestedFee(version, {
+      type: _types.TransactionType.DECLARE,
+      payload: declareContractPayload
+    }, {
+      ...details,
+      version
+    });
+    const declareDetails = {
+      ...(0, _stark.v3Details)(details),
+      resourceBounds: estimate.resourceBounds,
+      maxFee: estimate.maxFee,
+      nonce: (0, _num.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
+    } = (0, _transaction.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 (0, _events.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 = (0, _stark.toTransactionVersion)(this.getPreferredVersion(_api.ETransactionVersion.V1, _api.ETransactionVersion.V3), details.version);
+    const nonce = _constants.ZERO;
+    const chainId = await this.getChainId();
+    const compiledCalldata = _calldata.CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? (0, _hash.calculateContractAddressFromHash)(addressSalt, classHash, compiledCalldata, 0);
+    const estimate = await this.getUniversalSuggestedFee(version, {
+      type: _types.TransactionType.DEPLOY_ACCOUNT,
+      payload: {
+        classHash,
+        constructorCalldata: compiledCalldata,
+        addressSalt,
+        contractAddress
+      }
+    }, details);
+    const signature = await this.signer.signDeployAccountTransaction({
+      ...(0, _stark.v3Details)(details),
+      classHash,
+      constructorCalldata: compiledCalldata,
+      contractAddress,
+      addressSalt,
+      chainId,
+      resourceBounds: estimate.resourceBounds,
+      maxFee: estimate.maxFee,
+      version,
+      nonce
+    });
+    return this.deployAccountContract({
+      classHash,
+      addressSalt,
+      constructorCalldata,
+      signature
+    }, {
+      ...(0, _stark.v3Details)(details),
+      nonce,
+      resourceBounds: estimate.resourceBounds,
+      maxFee: estimate.maxFee,
+      version
+    });
+  }
+  async signMessage(typedData) {
+    return this.signer.signMessage(typedData, this.address);
+  }
+  async hashMessage(typedData) {
+    return (0, _typedData.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.CallData.compile({
+            hash: (0, _num.toBigInt)(hash).toString(),
+            signature: (0, _stark.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 = (0, _stark.estimateFeeToBounds)(_constants.ZERO);
+    if (version === _api.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 _types.TransactionType.INVOKE:
+        feeEstimate = await this.estimateInvokeFee(payload, details);
+        break;
+      case _types.TransactionType.DECLARE:
+        feeEstimate = await this.estimateDeclareFee(payload, details);
+        break;
+      case _types.TransactionType.DEPLOY_ACCOUNT:
+        feeEstimate = await this.estimateAccountDeployFee(payload, details);
+        break;
+      case _types.TransactionType.DEPLOY:
+        feeEstimate = await this.estimateDeployFee(payload, details);
+        break;
+      default:
+        feeEstimate = {
+          gas_consumed: 0n,
+          gas_price: 0n,
+          overall_fee: _constants.ZERO,
+          unit: "FRI",
+          suggestedMaxFee: _constants.ZERO,
+          resourceBounds: (0, _stark.estimateFeeToBounds)(_constants.ZERO),
+          data_gas_consumed: 0n,
+          data_gas_price: 0n
+        };
+        break;
+    }
+    return feeEstimate;
+  }
+  async buildInvocation(call, details) {
+    const calldata = (0, _transaction.getExecuteCalldata)(call, await this.getCairoVersion());
+    const signature = !details.skipValidate ? await this.signer.signTransaction(call, details) : [];
+    return {
+      ...(0, _stark.v3Details)(details),
+      contractAddress: this.address,
+      calldata,
+      signature
+    };
+  }
+  async buildDeclarePayload(payload, details) {
+    const {
+      classHash,
+      contract,
+      compiledClassHash
+    } = (0, _contract.extractContractHashes)(payload);
+    const compressedCompiledContract = (0, _provider2.parseContract)(contract);
+    if (typeof compiledClassHash === "undefined" && (details.version === _api.ETransactionVersion3.F3 || details.version === _api.ETransactionVersion3.V3)) {
+      throw Error("V3 Transaction work with Cairo1 Contracts and require compiledClassHash");
+    }
+    const signature = !details.skipValidate ? await this.signer.signDeclareTransaction({
+      ...details,
+      ...(0, _stark.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.CallData.compile(constructorCalldata);
+    const contractAddress = providedContractAddress ?? (0, _hash.calculateContractAddressFromHash)(addressSalt, classHash, compiledCalldata, 0);
+    const signature = !details.skipValidate ? await this.signer.signDeployAccountTransaction({
+      ...details,
+      ...(0, _stark.v3Details)(details),
+      classHash,
+      contractAddress,
+      addressSalt,
+      constructorCalldata: compiledCalldata
+    }) : [];
+    return {
+      ...(0, _stark.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.CallData.compile(constructorCalldata);
+      return {
+        contractAddress: _constants.UDC.ADDRESS,
+        entrypoint: _constants.UDC.ENTRYPOINT,
+        calldata: [classHash, salt, (0, _num.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 => (0, _stark.toTransactionVersion)(it));
+    const tx0Payload = "payload" in invocations[0] ? invocations[0].payload : invocations[0];
+    const cairoVersion = invocations[0].type === _types.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 = {
+        ...(0, _stark.v3Details)(details),
+        walletAddress: this.address,
+        nonce: (0, _num.toBigInt)(Number(safeNonce) + index),
+        maxFee: _constants.ZERO,
+        chainId,
+        cairoVersion,
+        version: "",
+        skipValidate
+      };
+      const common = {
+        type: transaction.type,
+        nonce: (0, _num.toBigInt)(Number(safeNonce) + index),
+        blockIdentifier,
+        version: ""
+      };
+      if (transaction.type === _types.TransactionType.INVOKE) {
+        const versionX = (0, _stark.reduceV2)(versions[1]);
+        signerDetails.version = versionX;
+        common.version = versionX;
+        const payload = await this.buildInvocation([].concat(txPayload), signerDetails);
+        return {
+          ...common,
+          ...payload
+        };
+      }
+      if (transaction.type === _types.TransactionType.DEPLOY) {
+        const versionX = (0, _stark.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: _types.TransactionType.INVOKE
+        };
+      }
+      if (transaction.type === _types.TransactionType.DECLARE) {
+        const versionX = !(0, _contract.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 === _types.TransactionType.DEPLOY_ACCOUNT) {
+        const versionX = (0, _stark.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);
+  }
+}
+exports.Account = Account;