starknet 4.13.2 → 4.15.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, retryInterval = 8e3, successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"]) {
+    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;
@@ -3074,8 +3083,11 @@ var HttpError = class extends CustomError {
 function isEmptyQueryObject(obj) {
   return obj === void 0 || Object.keys(obj).length === 0 || Object.keys(obj).length === 1 && Object.entries(obj).every(([k, v]) => k === "blockIdentifier" && v === null);
 }
+var defaultOptions = {
+  network: "goerli-alpha-2"
+};
 var SequencerProvider = class {
-  constructor(optionsOrProvider = { network: "goerli-alpha-2" }) {
+  constructor(optionsOrProvider = defaultOptions) {
     this.responseParser = new SequencerAPIResponseParser();
     if ("network" in optionsOrProvider) {
       this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
@@ -3112,6 +3124,9 @@ var SequencerProvider = class {
       if (url.host.includes("mainnet.starknet.io")) {
         return "0x534e5f4d41494e" /* MAINNET */;
       }
+      if (url.host.includes("alpha4-2.starknet.io")) {
+        return "0x534e5f474f45524c4932" /* TESTNET2 */;
+      }
     } catch {
       console.error(`Could not parse baseUrl: ${baseUrl}`);
     }
@@ -3214,7 +3229,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 +3359,13 @@ var SequencerProvider = class {
   async getCode(contractAddress, blockIdentifier = "pending") {
     return this.fetchEndpoint("get_code", { contractAddress, blockIdentifier });
   }
-  async waitForTransaction(txHash, retryInterval = 8e3) {
+  async waitForTransaction(txHash, retryInterval = 8e3, successStates = ["ACCEPTED_ON_L1", "ACCEPTED_ON_L2", "PENDING"]) {
+    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 +3376,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 +3404,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 +3444,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 +3480,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, retryInterval, successStates) {
+    return this.provider.waitForTransaction(txHash, retryInterval, successStates);
   }
 };
 
@@ -3478,12 +3497,18 @@ function parseFelt(candidate) {
   try {
     return toBN(candidate);
   } catch (e) {
-    throw Error("Couldnt parse felt");
+    throw Error("Could not parse felt");
   }
 }
 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 +3733,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 +3758,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 +3771,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,35 +3928,42 @@ 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);
   }
 };
 
+// src/account/default.ts
+import { BN as BN5 } from "bn.js";
+
 // src/signer/interface.ts
 var SignerInterface = class {
 };
@@ -4272,6 +4304,122 @@ 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/utils/starknetId.ts
+import BN4 from "bn.js";
+var basicAlphabet = "abcdefghijklmnopqrstuvwxyz0123456789-";
+var basicSizePlusOne = new BN4(basicAlphabet.length + 1);
+var bigAlphabet = "\u8FD9\u6765";
+var basicAlphabetSize = new BN4(basicAlphabet.length);
+var bigAlphabetSize = new BN4(bigAlphabet.length);
+var bigAlphabetSizePlusOne = new BN4(bigAlphabet.length + 1);
+function extractStars(str) {
+  let k = 0;
+  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+    str = str.substring(0, str.length - 1);
+    k += 1;
+  }
+  return [str, k];
+}
+function useDecoded(encoded) {
+  let decoded = "";
+  encoded.forEach((subdomain) => {
+    while (!subdomain.isZero()) {
+      const code = subdomain.mod(basicSizePlusOne).toNumber();
+      subdomain = subdomain.div(basicSizePlusOne);
+      if (code === basicAlphabet.length) {
+        const nextSubdomain = subdomain.div(bigAlphabetSizePlusOne);
+        if (nextSubdomain.isZero()) {
+          const code2 = subdomain.mod(bigAlphabetSizePlusOne).toNumber();
+          subdomain = nextSubdomain;
+          if (code2 === 0)
+            decoded += basicAlphabet[0];
+          else
+            decoded += bigAlphabet[code2 - 1];
+        } else {
+          const code2 = subdomain.mod(bigAlphabetSize).toNumber();
+          decoded += bigAlphabet[code2];
+          subdomain = subdomain.div(bigAlphabetSize);
+        }
+      } else
+        decoded += basicAlphabet[code];
+    }
+    const [str, k] = extractStars(decoded);
+    if (k)
+      decoded = str + (k % 2 === 0 ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) + bigAlphabet[0] + basicAlphabet[1] : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+    decoded += ".";
+  });
+  return decoded.concat("stark");
+}
+function useEncoded(decoded) {
+  let encoded = new BN4(0);
+  let multiplier = new BN4(1);
+  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+  } else {
+    const [str, k] = extractStars(decoded);
+    if (k)
+      decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+  }
+  for (let i = 0; i < decoded.length; i += 1) {
+    const char = decoded[i];
+    const index = basicAlphabet.indexOf(char);
+    const bnIndex = new BN4(basicAlphabet.indexOf(char));
+    if (index !== -1) {
+      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
+        encoded = encoded.add(multiplier.mul(basicAlphabetSize));
+        multiplier = multiplier.mul(basicSizePlusOne);
+        multiplier = multiplier.mul(basicSizePlusOne);
+      } else {
+        encoded = encoded.add(multiplier.mul(bnIndex));
+        multiplier = multiplier.mul(basicSizePlusOne);
+      }
+    } else if (bigAlphabet.indexOf(char) !== -1) {
+      encoded = encoded.add(multiplier.mul(basicAlphabetSize));
+      multiplier = multiplier.mul(basicSizePlusOne);
+      const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
+      encoded = encoded.add(multiplier.mul(new BN4(newid)));
+      multiplier = multiplier.mul(bigAlphabetSize);
+    }
+  }
+  return encoded;
+}
+function getStarknetIdContract(chainId) {
+  const starknetIdMainnetContract = "0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678";
+  const starknetIdTestnetContract = "0x05cf267a0af6101667013fc6bd3f6c11116a14cda9b8c4b1198520d59f900b17";
+  switch (chainId) {
+    case "0x534e5f4d41494e" /* MAINNET */:
+      return starknetIdMainnetContract;
+    case "0x534e5f474f45524c49" /* TESTNET */:
+      return starknetIdTestnetContract;
+    default:
+      throw new Error("Starknet.id is not yet deployed on this network");
+  }
+}
+
 // src/account/default.ts
 var Account = class extends Provider {
   constructor(providerOrOptions, address, keyPairOrSigner) {
@@ -4280,7 +4428,41 @@ 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 getStarkName(StarknetIdContract) {
+    const chainId = await this.getChainId();
+    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
+    try {
+      const hexDomain = await this.callContract({
+        contractAddress: contract,
+        entrypoint: "address_to_domain",
+        calldata: compileCalldata({
+          address: this.address
+        })
+      });
+      const decimalDomain = hexDomain.result.map((element) => new BN5(hexToDecimalString(element))).slice(1);
+      const stringDomain = useDecoded(decimalDomain);
+      return stringDomain;
+    } catch {
+      return Error("Could not get stark name");
+    }
+  }
+  async getAddressFromStarkName(name, StarknetIdContract) {
+    const chainId = await this.getChainId();
+    const contract = StarknetIdContract ?? getStarknetIdContract(chainId);
+    try {
+      const addressData = await this.callContract({
+        contractAddress: contract,
+        entrypoint: "domain_to_address",
+        calldata: compileCalldata({
+          domain: [useEncoded(name.replace(".stark", "")).toString(10)]
+        })
+      });
+      return addressData.result[0];
+    } catch {
+      return Error("Could not get address from stark name");
+    }
   }
   async estimateFee(calls, estimateFeeDetails) {
     return this.estimateInvokeFee(calls, estimateFeeDetails);
@@ -4367,7 +4549,7 @@ var Account = class extends Provider {
   }
   async estimateDeployFee({
     classHash,
-    salt,
+    salt = "0",
     unique = true,
     constructorCalldata = [],
     additionalCalls = []
@@ -4448,9 +4630,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 +4641,7 @@ var Account = class extends Provider {
           entrypoint: UDC.ENTRYPOINT,
           calldata: [
             classHash,
-            salt,
+            deploySalt,
             toCairoBool(unique),
             compiledConstructorCallData.length,
             ...compiledConstructorCallData
@@ -4467,9 +4650,22 @@ 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, void 0, [
+      "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, void 0, ["ACCEPTED_ON_L2"]);
+    const deploy = await this.deployContract({ classHash, constructorCalldata }, details);
+    return { declare: { ...declare, class_hash: classHash }, deploy };
+  }
   async deployAccount({
     classHash,
     constructorCalldata = [],