starknet 4.13.2 → 4.15.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.13.2",
+  "version": "4.15.0",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -21,7 +21,7 @@
     "build:iife": "tsup --clean false --format iife --platform browser",
     "build:dts": "tsup --clean false --dts-only",
     "pretest": "npm run lint",
-    "test": "jest",
+    "test": "jest -i",
     "posttest": "npm run format",
     "test:watch": "jest --watch",
     "docs": "cd www && npm run start",
@@ -87,7 +87,7 @@
     "json-bigint": "^1.0.0",
     "minimalistic-assert": "^1.0.1",
     "pako": "^2.0.4",
-    "ts-custom-error": "^3.2.0",
+    "ts-custom-error": "^3.3.1",
     "url-join": "^4.0.1"
   },
   "lint-staged": {

package/src/account/default.ts

@@ -1,3 +1,5 @@
+import { BN } from 'bn.js';
+
 import { UDC, ZERO } from '../constants';
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
@@ -9,8 +11,10 @@ import {
   Call,
   DeclareContractPayload,
   DeclareContractResponse,
+  DeclareDeployContractPayload,
   DeployAccountContractPayload,
   DeployContractResponse,
+  DeployContractUDCResponse,
   EstimateFee,
   EstimateFeeAction,
   EstimateFeeDetails,
@@ -21,14 +25,16 @@ import {
   Signature,
   UniversalDeployerContractPayload,
 } from '../types';
+import { parseUDCEvent } from '../utils/events';
 import {
   calculateContractAddressFromHash,
   feeTransactionVersion,
   transactionVersion,
 } from '../utils/hash';
-import { BigNumberish, toBN, toCairoBool } from '../utils/number';
+import { BigNumberish, hexToDecimalString, toBN, toCairoBool } from '../utils/number';
 import { parseContract } from '../utils/provider';
-import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
+import { compileCalldata, estimatedFeeToMaxFee, randomAddress } from '../utils/stark';
+import { getStarknetIdContract, useDecoded, useEncoded } from '../utils/starknetId';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -50,7 +56,53 @@ export class Account extends Provider implements AccountInterface {
   }
 
   public async getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish> {
-    return super.getNonce(this.address, blockIdentifier);
+    return super.getNonceForAddress(this.address, blockIdentifier);
+  }
+
+  public async getStarkName(StarknetIdContract?: string): Promise<string | Error> {
+    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 BN(hexToDecimalString(element)))
+        .slice(1);
+
+      const stringDomain = useDecoded(decimalDomain);
+
+      return stringDomain;
+    } catch {
+      return Error('Could not get stark name');
+    }
+  }
+
+  public async getAddressFromStarkName(
+    name: string,
+    StarknetIdContract?: string
+  ): Promise<string | Error> {
+    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');
+    }
   }
 
   public async estimateFee(
@@ -168,7 +220,7 @@ export class Account extends Provider implements AccountInterface {
   public async estimateDeployFee(
     {
       classHash,
-      salt,
+      salt = '0',
       unique = true,
       constructorCalldata = [],
       additionalCalls = [],
@@ -276,11 +328,11 @@ export class Account extends Provider implements AccountInterface {
       constructorCalldata = [],
       additionalCalls = [],
     }: UniversalDeployerContractPayload,
-    transactionsDetail: InvocationsDetails = {}
+    invocationsDetails: InvocationsDetails = {}
   ): Promise<InvokeFunctionResponse> {
     const compiledConstructorCallData = compileCalldata(constructorCalldata);
-
     const callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+    const deploySalt = salt ?? randomAddress();
 
     return this.execute(
       [
@@ -289,7 +341,7 @@ export class Account extends Provider implements AccountInterface {
           entrypoint: UDC.ENTRYPOINT,
           calldata: [
             classHash,
-            salt,
+            deploySalt,
             toCairoBool(unique),
             compiledConstructorCallData.length,
             ...compiledConstructorCallData,
@@ -298,10 +350,31 @@ export class Account extends Provider implements AccountInterface {
         ...callsArray,
       ],
       undefined,
-      transactionsDetail
+      invocationsDetails
     );
   }
 
+  public async deployContract(
+    payload: UniversalDeployerContractPayload,
+    details: InvocationsDetails = {}
+  ): Promise<DeployContractUDCResponse> {
+    const deployTx = await this.deploy(payload, details);
+    const txReceipt = await this.waitForTransaction(deployTx.transaction_hash, undefined, [
+      'ACCEPTED_ON_L2',
+    ]);
+    return parseUDCEvent(txReceipt);
+  }
+
+  public async declareDeploy(
+    { classHash, contract, constructorCalldata }: DeclareDeployContractPayload,
+    details?: InvocationsDetails
+  ) {
+    const { transaction_hash } = await this.declare({ contract, classHash }, details);
+    const declare = await this.waitForTransaction(transaction_hash, undefined, ['ACCEPTED_ON_L2']);
+    const deploy = await this.deployContract({ classHash, constructorCalldata }, details);
+    return { declare: { ...declare, class_hash: classHash }, deploy };
+  }
+
   public async deployAccount(
     {
       classHash,

package/src/account/interface.ts

@@ -7,8 +7,11 @@ import {
   Call,
   DeclareContractPayload,
   DeclareContractResponse,
+  DeclareDeployContractPayload,
+  DeclareDeployContractResponse,
   DeployAccountContractPayload,
   DeployContractResponse,
+  DeployContractUDCResponse,
   EstimateFeeAction,
   EstimateFeeDetails,
   EstimateFeeResponse,
@@ -129,7 +132,6 @@ export abstract class AccountInterface extends ProviderInterface {
    * @param contractPayload transaction payload to be deployed containing:
   - contract: compiled contract code
   - classHash: computed class hash of compiled contract
-  - signature
    * @param transactionsDetail Invocation Details containing:
   - optional nonce
   - optional version
@@ -147,20 +149,84 @@ export abstract class AccountInterface extends ProviderInterface {
    *
    * @param deployContractPayload containing
    * - classHash: computed class hash of compiled contract
-   * - salt: address salt
-   * - unique: bool if true ensure unique salt
-   * - calldata: constructor calldata
-   * - additionalCalls - optional additional calls array to support multicall
+   * - constructorCalldata: constructor calldata
+   * - optional salt: address salt - default random
+   * - optional unique: bool if true ensure unique salt - default true
+   * - optional additionalCalls - optional additional calls array to support multi-call
    * @param transactionsDetail Invocation Details containing:
    *  - optional nonce
    *  - optional version
    *  - optional maxFee
+   * @returns Promise<InvokeFunctionResponse>
+   *  - transaction_hash
    */
   public abstract deploy(
     deployContractPayload: UniversalDeployerContractPayload,
     transactionsDetail?: InvocationsDetails
   ): Promise<InvokeFunctionResponse>;
 
+  /**
+   * Simplify deploy simulating old DeployContract with same response + UDC specific response
+   *
+   * @param payload UniversalDeployerContractPayload
+   *  - classHash: computed class hash of compiled contract
+   *  - constructorCalldata: constructor calldata
+   *  - optional salt: address salt - default random
+   *  - optional unique: bool if true ensure unique salt - default true
+   *  - optional additionalCalls - optional additional calls array to support multi-call
+   * @param details InvocationsDetails
+   *  - optional nonce
+   *  - optional version
+   *  - optional maxFee
+   * @returns Promise<DeployContractUDCResponse>
+   *  - contract_address
+   *  - transaction_hash
+   *  - address
+   *  - deployer
+   *  - unique
+   *  - classHash
+   *  - calldata_len
+   *  - calldata
+   *  - salt
+   */
+  public abstract deployContract(
+    payload: UniversalDeployerContractPayload,
+    details: InvocationsDetails
+  ): Promise<DeployContractUDCResponse>;
+
+  /**
+   * Declares and Deploy a given compiled contract (json) to starknet using UDC
+   *
+   * @param declareDeployerContractPayload containing
+   * - contract: compiled contract code
+   * - classHash: computed class hash of compiled contract
+   * - optional constructorCalldata: constructor calldata
+   * - optional salt: address salt - default random
+   * - optional unique: bool if true ensure unique salt - default true
+   * - optional additionalCalls: - optional additional calls array to support multicall
+   * @param details
+   * - optional nonce
+   * - optional version
+   * - optional maxFee
+   * @returns Promise<DeclareDeployContractResponse>
+   * - declare
+   *    - transaction_hash
+   * - deploy
+   *    - contract_address
+   *    - transaction_hash
+   *    - address
+   *    - deployer
+   *    - unique
+   *    - classHash
+   *    - calldata_len
+   *    - calldata
+   *    - salt
+   */
+  public abstract declareDeploy(
+    declareDeployerContractPayload: DeclareDeployContractPayload,
+    details?: InvocationsDetails
+  ): Promise<DeclareDeployContractResponse>;
+
   /**
    * Deploy the account on Starknet
    * 

package/src/contract/contractFactory.ts

@@ -1,8 +1,7 @@
 import assert from 'minimalistic-assert';
 
 import { AccountInterface } from '../account';
-import { ProviderInterface, defaultProvider } from '../provider';
-import { Abi, CompiledContract, RawCalldata } from '../types';
+import { Abi, CompiledContract, RawArgs } from '../types';
 import { Contract } from './default';
 
 export class ContractFactory {
@@ -10,16 +9,20 @@ export class ContractFactory {
 
   compiledContract: CompiledContract;
 
-  providerOrAccount: ProviderInterface | AccountInterface;
+  classHash: string;
+
+  account: AccountInterface;
 
   constructor(
     compiledContract: CompiledContract,
-    providerOrAccount: ProviderInterface | AccountInterface = defaultProvider,
+    classHash: string,
+    account: AccountInterface,
     abi: Abi = compiledContract.abi // abi can be different from the deployed contract ie for proxy contracts
   ) {
     this.abi = abi;
     this.compiledContract = compiledContract;
-    this.providerOrAccount = providerOrAccount;
+    this.account = account;
+    this.classHash = classHash;
   }
 
   /**
@@ -30,20 +33,23 @@ export class ContractFactory {
    * @returns deployed Contract
    */
   public async deploy(
-    constructorCalldata?: RawCalldata,
+    constructorCalldata?: RawArgs,
     addressSalt?: string | undefined
   ): Promise<Contract> {
-    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,
     });
     assert(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;
 
@@ -53,10 +59,11 @@ export class ContractFactory {
   /**
    * Attaches to new Provider or Account
    *
-   * @param providerOrAccount - new Provider or Account to attach to
+   * @param account - new Provider or Account to attach to
+   * @returns ContractFactory
    */
-  connect(providerOrAccount: ProviderInterface | AccountInterface): ContractFactory {
-    this.providerOrAccount = providerOrAccount;
+  connect(account: AccountInterface): ContractFactory {
+    this.account = account;
     return this;
   }
 
@@ -67,7 +74,7 @@ export class ContractFactory {
    * @returns Contract
    */
   attach(address: string): Contract {
-    return new Contract(this.abi, address, this.providerOrAccount);
+    return new Contract(this.abi, address, this.account);
   }
 
   // ethers.js' getDeployTransaction cant be supported as it requires the account or signer to return a signed transaction which is not possible with the current implementation

package/src/contract/default.ts

@@ -9,6 +9,7 @@ import {
   AbiEntry,
   Args,
   AsyncContractFunction,
+  BlockTag,
   Call,
   Calldata,
   ContractFunction,
@@ -26,7 +27,7 @@ function parseFelt(candidate: string): BN {
   try {
     return toBN(candidate);
   } catch (e) {
-    throw Error('Couldnt parse felt');
+    throw Error('Could not parse felt');
   }
 }
 
@@ -36,7 +37,15 @@ function parseFelt(candidate: string): BN {
  */
 function buildCall(contract: Contract, functionAbi: FunctionAbi): AsyncContractFunction {
   return async function (...args: Array<any>): Promise<any> {
-    return contract.call(functionAbi.name, args);
+    let blockIdentifier: BlockTag | null = null;
+
+    args.forEach((arg) => {
+      if (arg.blockIdentifier) {
+        blockIdentifier = arg.blockIdentifier;
+      }
+    });
+
+    return contract.call(functionAbi.name, args, { blockIdentifier });
   };
 }
 

package/src/provider/default.ts

@@ -17,6 +17,7 @@ import {
   InvocationsDetails,
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
+  Status,
 } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -33,13 +34,23 @@ export class Provider implements ProviderInterface {
   private provider!: ProviderInterface;
 
   constructor(providerOrOptions?: ProviderOptions | ProviderInterface) {
-    if (providerOrOptions && 'chainId' in providerOrOptions) {
-      this.provider = providerOrOptions;
-    } else if (providerOrOptions?.rpc) {
-      this.provider = new RpcProvider(providerOrOptions.rpc);
-    } else if (providerOrOptions?.sequencer) {
-      this.provider = new SequencerProvider(providerOrOptions.sequencer);
+    if (providerOrOptions instanceof Provider) {
+      // providerOrOptions is Provider
+      this.provider = providerOrOptions.provider;
+    } else if (
+      providerOrOptions instanceof RpcProvider ||
+      providerOrOptions instanceof SequencerProvider
+    ) {
+      // providerOrOptions is SequencerProvider or RpcProvider
+      this.provider = <ProviderInterface>providerOrOptions;
+    } else if (providerOrOptions && 'rpc' in providerOrOptions) {
+      // providerOrOptions is rpc option
+      this.provider = new RpcProvider(<RpcProviderOptions>providerOrOptions.rpc);
+    } else if (providerOrOptions && 'sequencer' in providerOrOptions) {
+      // providerOrOptions is sequencer option
+      this.provider = new SequencerProvider(<SequencerProviderOptions>providerOrOptions.sequencer);
     } else {
+      // providerOrOptions is none, create SequencerProvider as default
       this.provider = new SequencerProvider();
     }
   }
@@ -94,11 +105,11 @@ export class Provider implements ProviderInterface {
     );
   }
 
-  public async getNonce(
+  public async getNonceForAddress(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
   ): Promise<BigNumberish> {
-    return this.provider.getNonce(contractAddress, blockIdentifier);
+    return this.provider.getNonceForAddress(contractAddress, blockIdentifier);
   }
 
   public async getStorageAt(
@@ -135,7 +146,7 @@ export class Provider implements ProviderInterface {
    * @deprecated This method won't be supported, use Account.deploy instead
    */
   public async deployContract(
-    payload: DeployContractPayload,
+    payload: DeployContractPayload | any,
     details: InvocationsDetails
   ): Promise<DeployContractResponse> {
     return this.provider.deployContract(payload, details);
@@ -178,7 +189,11 @@ export class Provider implements ProviderInterface {
     return this.provider.getCode(contractAddress, blockIdentifier);
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void> {
-    return this.provider.waitForTransaction(txHash, retryInterval);
+  public async waitForTransaction(
+    txHash: BigNumberish,
+    retryInterval?: number,
+    successStates?: Array<Status>
+  ): Promise<any> {
+    return this.provider.waitForTransaction(txHash, retryInterval, successStates);
   }
 }

package/src/provider/interface.ts

@@ -18,6 +18,7 @@ import type {
   InvocationsDetails,
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
+  Status,
 } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
@@ -98,7 +99,7 @@ export abstract class ProviderInterface {
    * @param contractAddress - contract address
    * @returns the hex nonce
    */
-  public abstract getNonce(
+  public abstract getNonceForAddress(
     contractAddress: string,
     blockIdentifier?: BlockIdentifier
   ): Promise<BigNumberish>;
@@ -147,7 +148,7 @@ export abstract class ProviderInterface {
    * @returns a confirmation of sending a transaction on the starknet contract
    */
   public abstract deployContract(
-    payload: DeployContractPayload,
+    payload: DeployContractPayload | any,
     details?: InvocationsDetails
   ): Promise<DeployContractResponse>;
 
@@ -288,6 +289,11 @@ export abstract class ProviderInterface {
    * Wait for the transaction to be accepted
    * @param txHash - transaction hash
    * @param retryInterval - retry interval
+   * @return GetTransactionReceiptResponse
    */
-  public abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+  public abstract waitForTransaction(
+    txHash: BigNumberish,
+    retryInterval?: number,
+    successStates?: Array<Status>
+  ): Promise<GetTransactionReceiptResponse>;
 }

package/src/provider/rpc.ts

@@ -132,7 +132,7 @@ export class RpcProvider implements ProviderInterface {
     });
   }
 
-  public async getNonce(
+  public async getNonceForAddress(
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.Nonce> {
@@ -402,31 +402,34 @@ export class RpcProvider implements ProviderInterface {
     return this.fetchEndpoint('starknet_traceBlockTransactions', { block_hash: blockHash });
   }
 
-  public async waitForTransaction(txHash: string, retryInterval: number = 8000) {
+  public async waitForTransaction(
+    txHash: string,
+    retryInterval: number = 8000,
+    successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING']
+  ) {
+    const errorStates = ['REJECTED', 'NOT_RECEIVED'];
     let { retries } = this;
     let onchain = false;
+    let txReceipt: any = {};
 
     while (!onchain) {
-      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
-      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
-
       // eslint-disable-next-line no-await-in-loop
       await wait(retryInterval);
       try {
         // eslint-disable-next-line no-await-in-loop
-        const res = await this.getTransactionReceipt(txHash);
+        txReceipt = await this.getTransactionReceipt(txHash);
 
-        if (!('status' in res)) {
+        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) as Error & { response: any };
-          error.response = res;
+          error.response = txReceipt;
           throw error;
         }
       } catch (error: unknown) {
@@ -443,6 +446,7 @@ export class RpcProvider implements ProviderInterface {
     }
 
     await wait(retryInterval);
+    return txReceipt;
   }
 
   /**