starknet 4.13.2 → 4.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.13.2",
+  "version": "4.14.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",

package/src/account/default.ts

@@ -9,8 +9,10 @@ import {
   Call,
   DeclareContractPayload,
   DeclareContractResponse,
+  DeclareDeployContractPayload,
   DeployAccountContractPayload,
   DeployContractResponse,
+  DeployContractUDCResponse,
   EstimateFee,
   EstimateFeeAction,
   EstimateFeeDetails,
@@ -21,6 +23,7 @@ import {
   Signature,
   UniversalDeployerContractPayload,
 } from '../types';
+import { parseUDCEvent } from '../utils/events';
 import {
   calculateContractAddressFromHash,
   feeTransactionVersion,
@@ -28,7 +31,7 @@ import {
 } from '../utils/hash';
 import { BigNumberish, toBN, toCairoBool } from '../utils/number';
 import { parseContract } from '../utils/provider';
-import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
+import { compileCalldata, estimatedFeeToMaxFee, randomAddress } from '../utils/stark';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -50,7 +53,7 @@ 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 estimateFee(
@@ -168,7 +171,7 @@ export class Account extends Provider implements AccountInterface {
   public async estimateDeployFee(
     {
       classHash,
-      salt,
+      salt = '0',
       unique = true,
       constructorCalldata = [],
       additionalCalls = [],
@@ -276,11 +279,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 +292,7 @@ export class Account extends Provider implements AccountInterface {
           entrypoint: UDC.ENTRYPOINT,
           calldata: [
             classHash,
-            salt,
+            deploySalt,
             toCairoBool(unique),
             compiledConstructorCallData.length,
             ...compiledConstructorCallData,
@@ -298,10 +301,29 @@ 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, ['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, ['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,
@@ -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,
+    successStates?: Array<Status>,
+    retryInterval?: number
+  ): Promise<any> {
+    return this.provider.waitForTransaction(txHash, successStates, retryInterval);
   }
 }

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,
+    successStates?: Array<Status>,
+    retryInterval?: number
+  ): 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,
+    successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'],
+    retryInterval: number = 8000
+  ) {
+    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;
   }
 
   /**

package/src/provider/sequencer.ts

@@ -256,7 +256,7 @@ export class SequencerProvider implements ProviderInterface {
     );
   }
 
-  public async getNonce(
+  public async getNonceForAddress(
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
@@ -447,17 +447,20 @@ export class SequencerProvider implements ProviderInterface {
     return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier });
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
+  public async waitForTransaction(
+    txHash: BigNumberish,
+    successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'],
+    retryInterval: number = 8000
+  ) {
+    const errorStates = ['REJECTED', 'NOT_RECEIVED'];
     let onchain = false;
+    let res;
 
     while (!onchain) {
       // eslint-disable-next-line no-await-in-loop
       await wait(retryInterval);
       // eslint-disable-next-line no-await-in-loop
-      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;
@@ -470,6 +473,8 @@ export class SequencerProvider implements ProviderInterface {
         throw error;
       }
     }
+    const txReceipt = await this.getTransactionReceipt(txHash);
+    return txReceipt;
   }
 
   /**

package/src/provider/utils.ts

@@ -1,4 +1,6 @@
 /* eslint-disable max-classes-per-file */
+import { BN } from 'bn.js';
+
 import type { BlockNumber } from '../types';
 import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
@@ -34,6 +36,7 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // null appends nothing to the request url
 
 export type BlockIdentifier = BlockNumber | BigNumberish;
+export const validBlockTags = ['latest', 'pending'];
 
 export class Block {
   hash: BlockIdentifier = null;
@@ -42,22 +45,26 @@ export class Block {
 
   tag: BlockIdentifier = null;
 
-  private setIdentifier: (_identifier: BlockIdentifier) => void;
+  private setIdentifier(__identifier: BlockIdentifier) {
+    if (typeof __identifier === 'string' && isHex(__identifier)) {
+      this.hash = __identifier;
+    } else if (BN.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 {
+      // default
+      this.tag = 'pending';
+    }
+  }
 
   constructor(_identifier: BlockIdentifier) {
-    this.setIdentifier = function (__identifier: BlockIdentifier) {
-      if (typeof __identifier === 'string' && isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (typeof __identifier === 'number') {
-        this.number = __identifier;
-      } else {
-        this.tag = __identifier;
-      }
-    };
-
     this.setIdentifier(_identifier);
   }
 
+  // TODO: fix any
   get queryIdentifier(): any {
     if (this.number !== null) {
       return `blockNumber=${this.number}`;
@@ -70,6 +77,7 @@ export class Block {
     return `blockNumber=${this.tag}`;
   }
 
+  // TODO: fix any
   get identifier(): any {
     if (this.number !== null) {
       return { block_number: this.number };

package/src/types/account.ts

@@ -2,7 +2,7 @@ import BN from 'bn.js';
 
 import { BlockIdentifier } from '../provider/utils';
 import { BigNumberish } from '../utils/number';
-import { EstimateFeeResponse } from './provider';
+import { DeclareTransactionReceiptResponse, EstimateFeeResponse } from './provider';
 
 export interface EstimateFee extends EstimateFeeResponse {
   suggestedMaxFee: BN;
@@ -12,3 +12,23 @@ export interface EstimateFeeDetails {
   nonce?: BigNumberish;
   blockIdentifier?: BlockIdentifier;
 }
+
+export interface DeployContractResponse {
+  contract_address: string;
+  transaction_hash: string;
+}
+
+export interface DeployContractUDCResponse extends DeployContractResponse {
+  address: string;
+  deployer: string;
+  unique: string;
+  classHash: string;
+  calldata_len: string;
+  calldata: Array<string>;
+  salt: string;
+}
+
+export type DeclareDeployContractResponse = {
+  declare: DeclareTransactionReceiptResponse;
+  deploy: DeployContractUDCResponse;
+};

package/src/types/lib.ts

@@ -21,8 +21,8 @@ export interface ContractClass {
 
 export type UniversalDeployerContractPayload = {
   classHash: BigNumberish;
-  salt: string;
-  unique: boolean;
+  salt?: string;
+  unique?: boolean;
   constructorCalldata?: RawArgs;
   additionalCalls?: AllowArray<Call>; // support multicall
 };
@@ -52,6 +52,9 @@ export type DeclareContractPayload = {
   classHash: BigNumberish; // Once the classHash is included in CompiledContract, this can be removed
 };
 
+export type DeclareDeployContractPayload = DeclareContractPayload &
+  UniversalDeployerContractPayload;
+
 export type DeclareContractTransaction = {
   contractDefinition: ContractClass;
   senderAddress: string;

package/src/types/provider.ts

@@ -106,11 +106,6 @@ export interface InvokeFunctionResponse {
   transaction_hash: string;
 }
 
-export interface DeployContractResponse {
-  contract_address: string;
-  transaction_hash: string;
-}
-
 export interface DeclareContractResponse {
   transaction_hash: string;
   class_hash: string;