starknet 4.13.2 → 4.14.0

package/index.mjs

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/contract/default.ts
-import BN2 from "bn.js";
+import BN3 from "bn.js";
 import assert4 from "minimalistic-assert";
 
 // src/utils/fetchPonyfill.ts
@@ -62,6 +62,7 @@ __export(number_exports, {
   assertInRange: () => assertInRange,
   bigNumberishArrayToDecimalStringArray: () => bigNumberishArrayToDecimalStringArray,
   bigNumberishArrayToHexadecimalStringArray: () => bigNumberishArrayToHexadecimalStringArray,
+  cleanHex: () => cleanHex,
   getDecimalString: () => getDecimalString,
   getHexString: () => getHexString,
   getHexStringArray: () => getHexStringArray,
@@ -164,6 +165,7 @@ function toFelt(num) {
   }
   return toBN(num).toString();
 }
+var cleanHex = (hex) => hex.toLowerCase().replace(/^(0x)0+/, "$1");
 function assertInRange(input, lowerBound, upperBound, inputName = "") {
   const messageSuffix = inputName === "" ? "invalid length" : `invalid ${inputName} length`;
   const inputBn = toBN(input);
@@ -2595,6 +2597,8 @@ var RPCResponseParser = class {
 };
 
 // src/provider/utils.ts
+import { BN as BN2 } from "bn.js";
+var validBlockTags = ["latest", "pending"];
 var Block = class {
   constructor(_identifier) {
     this.hash = null;
@@ -2602,17 +2606,21 @@ var Block = class {
     this.tag = null;
     this.valueOf = () => this.number;
     this.toString = () => this.hash;
-    this.setIdentifier = function(__identifier) {
-      if (typeof __identifier === "string" && isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (typeof __identifier === "number") {
-        this.number = __identifier;
-      } else {
-        this.tag = __identifier;
-      }
-    };
     this.setIdentifier(_identifier);
   }
+  setIdentifier(__identifier) {
+    if (typeof __identifier === "string" && isHex(__identifier)) {
+      this.hash = __identifier;
+    } else if (BN2.isBN(__identifier)) {
+      this.hash = toHex(__identifier);
+    } else if (typeof __identifier === "number") {
+      this.number = __identifier;
+    } else if (typeof __identifier === "string" && validBlockTags.includes(__identifier)) {
+      this.tag = __identifier;
+    } else {
+      this.tag = "pending";
+    }
+  }
   get queryIdentifier() {
     if (this.number !== null) {
       return `blockNumber=${this.number}`;
@@ -2699,7 +2707,7 @@ var RpcProvider = class {
       contract_address: contractAddress
     });
   }
-  async getNonce(contractAddress, blockIdentifier = "pending") {
+  async getNonceForAddress(contractAddress, blockIdentifier = "pending") {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint("starknet_getNonce", {
       contract_address: contractAddress,
@@ -2884,25 +2892,25 @@ var RpcProvider = class {
   async traceBlockTransactions(blockHash) {
     return this.fetchEndpoint("starknet_traceBlockTransactions", { block_hash: blockHash });
   }
-  async waitForTransaction(txHash, retryInterval = 8e3) {
+  async waitForTransaction(txHash, successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"], retryInterval = 8e3) {
+    const errorStates = ["REJECTED", "NOT_RECEIVED"];
     let { retries } = this;
     let onchain = false;
+    let txReceipt = {};
     while (!onchain) {
-      const successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"];
-      const errorStates = ["REJECTED", "NOT_RECEIVED"];
       await wait(retryInterval);
       try {
-        const res = await this.getTransactionReceipt(txHash);
-        if (!("status" in res)) {
+        txReceipt = await this.getTransactionReceipt(txHash);
+        if (!("status" in txReceipt)) {
           const error = new Error("pending transaction");
           throw error;
         }
-        if (res.status && successStates.includes(res.status)) {
+        if (txReceipt.status && successStates.includes(txReceipt.status)) {
           onchain = true;
-        } else if (res.status && errorStates.includes(res.status)) {
-          const message = res.status;
+        } else if (txReceipt.status && errorStates.includes(txReceipt.status)) {
+          const message = txReceipt.status;
           const error = new Error(message);
-          error.response = res;
+          error.response = txReceipt;
           throw error;
         }
       } catch (error) {
@@ -2916,6 +2924,7 @@ var RpcProvider = class {
       retries -= 1;
     }
     await wait(retryInterval);
+    return txReceipt;
   }
   async getTransactionCount(blockIdentifier = "pending") {
     const block_id = new Block(blockIdentifier).identifier;
@@ -3214,7 +3223,7 @@ var SequencerProvider = class {
       this.responseParser.parseGetBlockResponse
     );
   }
-  async getNonce(contractAddress, blockIdentifier = "pending") {
+  async getNonceForAddress(contractAddress, blockIdentifier = "pending") {
     return this.fetchEndpoint("get_nonce", { contractAddress, blockIdentifier });
   }
   async getStorageAt(contractAddress, key, blockIdentifier = "pending") {
@@ -3344,13 +3353,13 @@ var SequencerProvider = class {
   async getCode(contractAddress, blockIdentifier = "pending") {
     return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
   }
-  async waitForTransaction(txHash, retryInterval = 8e3) {
+  async waitForTransaction(txHash, successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"], retryInterval = 8e3) {
+    const errorStates = ["REJECTED", "NOT_RECEIVED"];
     let onchain = false;
+    let res;
     while (!onchain) {
       await wait(retryInterval);
-      const res = await this.getTransactionStatus(txHash);
-      const successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"];
-      const errorStates = ["REJECTED", "NOT_RECEIVED"];
+      res = await this.getTransactionStatus(txHash);
       if (successStates.includes(res.tx_status)) {
         onchain = true;
       } else if (errorStates.includes(res.tx_status)) {
@@ -3361,6 +3370,8 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
         throw error;
       }
     }
+    const txReceipt = await this.getTransactionReceipt(txHash);
+    return txReceipt;
   }
   async getTransactionStatus(txHash) {
     const txHashHex = toHex(toBN(txHash));
@@ -3387,11 +3398,13 @@ ${res.tx_failure_reason.error_message}` : res.tx_status;
 // src/provider/default.ts
 var Provider = class {
   constructor(providerOrOptions) {
-    if (providerOrOptions && "chainId" in providerOrOptions) {
+    if (providerOrOptions instanceof Provider) {
+      this.provider = providerOrOptions.provider;
+    } else if (providerOrOptions instanceof RpcProvider || providerOrOptions instanceof SequencerProvider) {
       this.provider = providerOrOptions;
-    } else if (providerOrOptions == null ? void 0 : providerOrOptions.rpc) {
+    } else if (providerOrOptions && "rpc" in providerOrOptions) {
       this.provider = new RpcProvider(providerOrOptions.rpc);
-    } else if (providerOrOptions == null ? void 0 : providerOrOptions.sequencer) {
+    } else if (providerOrOptions && "sequencer" in providerOrOptions) {
       this.provider = new SequencerProvider(providerOrOptions.sequencer);
     } else {
       this.provider = new SequencerProvider();
@@ -3425,8 +3438,8 @@ var Provider = class {
       blockIdentifier
     );
   }
-  async getNonce(contractAddress, blockIdentifier) {
-    return this.provider.getNonce(contractAddress, blockIdentifier);
+  async getNonceForAddress(contractAddress, blockIdentifier) {
+    return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
   }
   async getStorageAt(contractAddress, key, blockIdentifier = "pending") {
     return this.provider.getStorageAt(contractAddress, key, blockIdentifier);
@@ -3461,8 +3474,8 @@ var Provider = class {
   async getCode(contractAddress, blockIdentifier) {
     return this.provider.getCode(contractAddress, blockIdentifier);
   }
-  async waitForTransaction(txHash, retryInterval) {
-    return this.provider.waitForTransaction(txHash, retryInterval);
+  async waitForTransaction(txHash, successStates, retryInterval) {
+    return this.provider.waitForTransaction(txHash, successStates, retryInterval);
   }
 };
 
@@ -3483,7 +3496,13 @@ function parseFelt(candidate) {
 }
 function buildCall(contract, functionAbi) {
   return async function(...args) {
-    return contract.call(functionAbi.name, args);
+    let blockIdentifier = null;
+    args.forEach((arg) => {
+      if (arg.blockIdentifier) {
+        blockIdentifier = arg.blockIdentifier;
+      }
+    });
+    return contract.call(functionAbi.name, args, { blockIdentifier });
   };
 }
 function buildInvoke(contract, functionAbi) {
@@ -3708,7 +3727,7 @@ var Contract = class {
       }
       if (input.type === "felt") {
         assert4(
-          typeof args[argPosition] === "string" || typeof args[argPosition] === "number" || args[argPosition] instanceof BN2,
+          typeof args[argPosition] === "string" || typeof args[argPosition] === "number" || args[argPosition] instanceof BN3,
           `arg ${input.name} should be a felt (string, number, BigNumber)`
         );
         argPosition += 1;
@@ -3733,7 +3752,7 @@ var Contract = class {
         if (input.type === "felt*") {
           args[argPosition].forEach((felt) => {
             assert4(
-              typeof felt === "string" || typeof felt === "number" || felt instanceof BN2,
+              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
               `arg ${input.name} should be an array of string, number or BigNumber`
             );
           });
@@ -3746,7 +3765,7 @@ var Contract = class {
           );
           args[argPosition].forEach((felt) => {
             assert4(
-              typeof felt === "string" || typeof felt === "number" || felt instanceof BN2,
+              typeof felt === "string" || typeof felt === "number" || felt instanceof BN3,
               `arg ${input.name} should be an array of string, number or BigNumber`
             );
           });
@@ -3903,32 +3922,36 @@ var ContractInterface = class {
 // src/contract/contractFactory.ts
 import assert5 from "minimalistic-assert";
 var ContractFactory = class {
-  constructor(compiledContract, providerOrAccount = defaultProvider, abi = compiledContract.abi) {
+  constructor(compiledContract, classHash, account, abi = compiledContract.abi) {
     this.abi = abi;
     this.compiledContract = compiledContract;
-    this.providerOrAccount = providerOrAccount;
+    this.account = account;
+    this.classHash = classHash;
   }
   async deploy(constructorCalldata, addressSalt) {
-    const { contract_address, transaction_hash } = await this.providerOrAccount.deployContract({
+    const {
+      deploy: { contract_address, transaction_hash }
+    } = await this.account.declareDeploy({
       contract: this.compiledContract,
+      classHash: this.classHash,
       constructorCalldata,
-      addressSalt
+      salt: addressSalt
     });
     assert5(Boolean(contract_address), "Deployment of the contract failed");
     const contractInstance = new Contract(
       this.compiledContract.abi,
       contract_address,
-      this.providerOrAccount
+      this.account
     );
     contractInstance.deployTransactionHash = transaction_hash;
     return contractInstance;
   }
-  connect(providerOrAccount) {
-    this.providerOrAccount = providerOrAccount;
+  connect(account) {
+    this.account = account;
     return this;
   }
   attach(address) {
-    return new Contract(this.abi, address, this.providerOrAccount);
+    return new Contract(this.abi, address, this.account);
   }
 };
 
@@ -4272,6 +4295,29 @@ var Signer = class {
   }
 };
 
+// src/utils/events.ts
+function parseUDCEvent(txReceipt) {
+  if (!txReceipt.events) {
+    throw new Error("UDC emited event is empty");
+  }
+  const event = txReceipt.events.find(
+    (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
+  ) || {
+    data: []
+  };
+  return {
+    transaction_hash: txReceipt.transaction_hash,
+    contract_address: event.data[0],
+    address: event.data[0],
+    deployer: event.data[1],
+    unique: event.data[2],
+    classHash: event.data[3],
+    calldata_len: event.data[4],
+    calldata: event.data.slice(5, 5 + parseInt(event.data[4], 16)),
+    salt: event.data[event.data.length - 1]
+  };
+}
+
 // src/account/default.ts
 var Account = class extends Provider {
   constructor(providerOrOptions, address, keyPairOrSigner) {
@@ -4280,7 +4326,7 @@ var Account = class extends Provider {
     this.signer = "getPubKey" in keyPairOrSigner ? keyPairOrSigner : new Signer(keyPairOrSigner);
   }
   async getNonce(blockIdentifier) {
-    return super.getNonce(this.address, blockIdentifier);
+    return super.getNonceForAddress(this.address, blockIdentifier);
   }
   async estimateFee(calls, estimateFeeDetails) {
     return this.estimateInvokeFee(calls, estimateFeeDetails);
@@ -4367,7 +4413,7 @@ var Account = class extends Provider {
   }
   async estimateDeployFee({
     classHash,
-    salt,
+    salt = "0",
     unique = true,
     constructorCalldata = [],
     additionalCalls = []
@@ -4448,9 +4494,10 @@ var Account = class extends Provider {
     unique = true,
     constructorCalldata = [],
     additionalCalls = []
-  }, transactionsDetail = {}) {
+  }, invocationsDetails = {}) {
     const compiledConstructorCallData = compileCalldata(constructorCalldata);
     const callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+    const deploySalt = salt ?? randomAddress();
     return this.execute(
       [
         {
@@ -4458,7 +4505,7 @@ var Account = class extends Provider {
           entrypoint: UDC.ENTRYPOINT,
           calldata: [
             classHash,
-            salt,
+            deploySalt,
             toCairoBool(unique),
             compiledConstructorCallData.length,
             ...compiledConstructorCallData
@@ -4467,9 +4514,20 @@ var Account = class extends Provider {
         ...callsArray
       ],
       void 0,
-      transactionsDetail
+      invocationsDetails
     );
   }
+  async deployContract(payload, details = {}) {
+    const deployTx = await this.deploy(payload, details);
+    const txReceipt = await this.waitForTransaction(deployTx.transaction_hash, ["ACCEPTED_ON_L2"]);
+    return parseUDCEvent(txReceipt);
+  }
+  async declareDeploy({ classHash, contract, constructorCalldata }, details) {
+    const { transaction_hash } = await this.declare({ contract, classHash }, details);
+    const declare = await this.waitForTransaction(transaction_hash, ["ACCEPTED_ON_L2"]);
+    const deploy = await this.deployContract({ classHash, constructorCalldata }, details);
+    return { declare: { ...declare, class_hash: classHash }, deploy };
+  }
   async deployAccount({
     classHash,
     constructorCalldata = [],