starknet 4.9.0 → 4.11.0

package/src/account/default.ts

@@ -1,4 +1,4 @@
-import { ZERO } from '../constants';
+import { UDC, ZERO } from '../constants';
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
 import { BlockIdentifier } from '../provider/utils';
@@ -16,9 +16,18 @@ import {
   Signature,
 } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
-import { calculateContractAddressFromHash, transactionVersion } from '../utils/hash';
-import { BigNumberish, toBN } from '../utils/number';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
+import {
+  calculateContractAddressFromHash,
+  feeTransactionVersion,
+  transactionVersion,
+} from '../utils/hash';
+import { BigNumberish, toBN, toCairoBool } from '../utils/number';
 import { parseContract } from '../utils/provider';
 import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
@@ -58,7 +67,7 @@ export class Account extends Provider implements AccountInterface {
   ): Promise<EstimateFee> {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBN(providedNonce ?? (await this.getNonce()));
-    const version = toBN(transactionVersion);
+    const version = toBN(feeTransactionVersion);
     const chainId = await this.getChainId();
 
     const signerDetails: InvocationsSignerDetails = {
@@ -91,7 +100,7 @@ export class Account extends Provider implements AccountInterface {
     { blockIdentifier, nonce: providedNonce }: EstimateFeeDetails = {}
   ): Promise<EstimateFee> {
     const nonce = toBN(providedNonce ?? (await this.getNonce()));
-    const version = toBN(transactionVersion);
+    const version = toBN(feeTransactionVersion);
     const chainId = await this.getChainId();
     const contractDefinition = parseContract(contract);
 
@@ -127,7 +136,7 @@ export class Account extends Provider implements AccountInterface {
     { blockIdentifier, nonce: providedNonce }: EstimateFeeDetails = {}
   ): Promise<EstimateFee> {
     const nonce = toBN(providedNonce ?? (await this.getNonce()));
-    const version = toBN(transactionVersion);
+    const version = toBN(feeTransactionVersion);
     const chainId = await this.getChainId();
     const contractAddress =
       providedContractAddress ??
@@ -228,6 +237,41 @@ export class Account extends Provider implements AccountInterface {
     );
   }
 
+  public async deploy(
+    {
+      classHash,
+      salt,
+      unique = true,
+      constructorCalldata = [],
+      isDevnet = false,
+    }: UniversalDeployerContractPayload,
+    additionalCalls: AllowArray<Call> = [], // support multicall
+    transactionsDetail: InvocationsDetails = {}
+  ): Promise<InvokeFunctionResponse> {
+    const compiledConstructorCallData = compileCalldata(constructorCalldata);
+
+    const callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+
+    return this.execute(
+      [
+        {
+          contractAddress: isDevnet ? UDC.ADDRESS_DEVNET : UDC.ADDRESS,
+          entrypoint: UDC.ENTRYPOINT,
+          calldata: [
+            classHash,
+            salt,
+            toCairoBool(unique),
+            compiledConstructorCallData.length,
+            ...compiledConstructorCallData,
+          ],
+        },
+        ...callsArray,
+      ],
+      undefined,
+      transactionsDetail
+    );
+  }
+
   public async deployAccount(
     {
       classHash,

package/src/account/interface.ts

@@ -13,7 +13,12 @@ import {
   InvokeFunctionResponse,
   Signature,
 } from '../types';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
@@ -71,7 +76,7 @@ export abstract class AccountInterface extends ProviderInterface {
    * Estimate Fee for executing a DEPLOY_ACCOUNT transaction on starknet
    *
    * @param contractPayload the payload object containing:
-   * - contract - the compiled contract to be declared
+   * - contract - the compiled contract to be deployed
    * - classHash - the class hash of the compiled contract. This can be obtained by using starknet-cli.
    *
    * @returns response from estimate_fee
@@ -101,6 +106,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Declares a given compiled contract (json) to starknet
+   * 
    * @param contractPayload transaction payload to be deployed containing:
   - contract: compiled contract code
   - classHash: computed class hash of compiled contract
@@ -116,13 +122,32 @@ export abstract class AccountInterface extends ProviderInterface {
     transactionsDetail?: InvocationsDetails
   ): Promise<DeclareContractResponse>;
 
+  /**
+   * @param deployContractPayload containing
+   * - classHash: computed class hash of compiled contract
+   * - salt: address salt
+   * - unique: bool if true ensure unique salt
+   * - calldata: constructor calldata
+   * @param additionalCalls - optional additional calls array to support multicall
+   * @param transactionsDetail Invocation Details containing:
+   *  - optional nonce
+   *  - optional version
+   *  - optional maxFee
+   */
+  public abstract deploy(
+    deployContractPayload: UniversalDeployerContractPayload,
+    additionalCalls?: AllowArray<Call>,
+    transactionsDetail?: InvocationsDetails
+  ): Promise<InvokeFunctionResponse>;
+
   /**
    * Deploy the account on Starknet
+   * 
    * @param contractPayload transaction payload to be deployed containing:
-   * - classHash: computed class hash of compiled contract
-   * - constructor calldata
-   * - address salt  
-  - signature
+  - classHash: computed class hash of compiled contract
+  - optional constructor calldata
+  - optional address salt  
+  - optional contractAddress
    * @param transactionsDetail Invocation Details containing:
   - optional nonce
   - optional version
@@ -157,7 +182,7 @@ export abstract class AccountInterface extends ProviderInterface {
   /**
    * Verify a signature of a JSON object
    *
-   * @param json - JSON object to be verified
+   * @param typedData - JSON object to be verified
    * @param signature - signature of the JSON object
    * @returns true if the signature is valid, false otherwise
    * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature
@@ -177,6 +202,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Gets the nonce of the account with respect to a specific block
+   *
    * @param  {BlockIdentifier} blockIdentifier - optional blockIdentifier. Defaults to 'pending'
    * @returns nonce of the account
    */
@@ -184,6 +210,7 @@ export abstract class AccountInterface extends ProviderInterface {
 
   /**
    * Gets Suggested Max Fee based on the transaction type
+   *
    * @param  {EstimateFeeAction} estimateFeeAction
    * @param  {EstimateFeeDetails} details
    * @returns suggestedMaxFee

package/src/constants.ts

@@ -11,6 +11,7 @@ export const MASK_251 = TWO.pow(toBN(251));
 export enum StarknetChainId {
   MAINNET = '0x534e5f4d41494e', // encodeShortString('SN_MAIN'),
   TESTNET = '0x534e5f474f45524c49', // encodeShortString('SN_GOERLI'),
+  TESTNET2 = '0x534e5f474f45524c4932',
 }
 export enum TransactionHashPrefix {
   DECLARE = '0x6465636c617265', // encodeShortString('declare'),
@@ -20,6 +21,12 @@ export enum TransactionHashPrefix {
   L1_HANDLER = '0x6c315f68616e646c6572', // encodeShortString('l1_handler'),
 }
 
+export const UDC = {
+  ADDRESS: '0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf',
+  ENTRYPOINT: 'deployContract',
+  ADDRESS_DEVNET: '0x25fcb74260022bd8ed7e8d542408941826b53345e478b8303d6f31744838a36',
+};
+
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.

package/src/contract/default.ts

@@ -204,30 +204,14 @@ export class Contract implements ContractInterface {
     });
   }
 
-  /**
-   * Saves the address of the contract deployed on network that will be used for interaction
-   *
-   * @param address - address of the contract
-   */
   public attach(address: string): void {
     this.address = address;
   }
 
-  /**
-   * Attaches to new Provider or Account
-   *
-   * @param providerOrAccount - new Provider or Account to attach to
-   */
   public connect(providerOrAccount: ProviderInterface | AccountInterface) {
     this.providerOrAccount = providerOrAccount;
   }
 
-  /**
-   * Resolves when contract is deployed on the network or when no deployment transaction is found
-   *
-   * @returns Promise that resolves when contract is deployed on the network or when no deployment transaction is found
-   * @throws When deployment fails
-   */
   public async deployed(): Promise<Contract> {
     if (this.deployTransactionHash) {
       await this.providerOrAccount.waitForTransaction(this.deployTransactionHash);
@@ -236,6 +220,129 @@ export class Contract implements ContractInterface {
     return this;
   }
 
+  public async call(
+    method: string,
+    args: Array<any> = [],
+    {
+      blockIdentifier = 'pending',
+    }: {
+      blockIdentifier?: BlockIdentifier;
+    } = {}
+  ): Promise<Result> {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+
+    // validate method and args
+    this.validateMethodAndArgs('CALL', method, args);
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+
+    // compile calldata
+    const calldata = this.compileCalldata(args, inputs);
+    return this.providerOrAccount
+      .callContract(
+        {
+          contractAddress: this.address,
+          calldata,
+          entrypoint: method,
+        },
+        blockIdentifier
+      )
+      .then((x) => this.parseResponse(method, x.result));
+  }
+
+  public invoke(
+    method: string,
+    args: Array<any> = [],
+    options: Overrides = {}
+  ): Promise<InvokeFunctionResponse> {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+    // validate method and args
+    this.validateMethodAndArgs('INVOKE', method, args);
+
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+    const inputsLength = inputs.reduce((acc, input) => {
+      if (!/_len$/.test(input.name)) {
+        return acc + 1;
+      }
+      return acc;
+    }, 0);
+
+    if (args.length !== inputsLength) {
+      throw Error(
+        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
+      );
+    }
+    // compile calldata
+    const calldata = this.compileCalldata(args, inputs);
+
+    const invocation = {
+      contractAddress: this.address,
+      calldata,
+      entrypoint: method,
+    };
+    if ('execute' in this.providerOrAccount) {
+      return this.providerOrAccount.execute(invocation, undefined, {
+        maxFee: options.maxFee,
+        nonce: options.nonce,
+      });
+    }
+
+    if (!options.nonce) {
+      throw new Error(`Nonce is required when invoking a function without an account`);
+    }
+
+    // eslint-disable-next-line no-console
+    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
+
+    return this.providerOrAccount.invokeFunction(
+      {
+        ...invocation,
+        signature: options.signature || [],
+      },
+      {
+        nonce: options.nonce,
+      }
+    );
+  }
+
+  public async estimate(method: string, args: Array<any> = []) {
+    // ensure contract is connected
+    assert(this.address !== null, 'contract is not connected to an address');
+
+    // validate method and args
+    this.validateMethodAndArgs('INVOKE', method, args);
+    const invocation = this.populateTransaction[method](...args);
+    if ('estimateInvokeFee' in this.providerOrAccount) {
+      return this.providerOrAccount.estimateInvokeFee(invocation);
+    }
+    throw Error('Contract must be connected to the account contract to estimate');
+  }
+
+  public populate(method: string, args: Array<any> = []): Call {
+    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
+    return {
+      contractAddress: this.address,
+      entrypoint: method,
+      calldata: this.compileCalldata(args, inputs),
+    };
+  }
+
+  /**
+   * Deep parse of the object that has been passed to the method
+   *
+   * @param struct - struct that needs to be calculated
+   * @return {number} - number of members for the given struct
+   */
+  private calculateStructMembers(struct: string): number {
+    return this.structs[struct].members.reduce((acc, member) => {
+      if (member.type === 'felt') {
+        return acc + 1;
+      }
+      return acc + this.calculateStructMembers(member.type);
+    }, 0);
+  }
+
   /**
    * Validates if all arguments that are passed to the method are corresponding to the ones in the abi
    *
@@ -337,22 +444,6 @@ export class Contract implements ContractInterface {
     });
   }
 
-  /**
-   * Deep parse of the object that has been passed to the method
-   *
-   * @param struct - struct that needs to be calculated
-   * @return {number} - number of members for the given struct
-   */
-
-  private calculateStructMembers(struct: string): number {
-    return this.structs[struct].members.reduce((acc, member) => {
-      if (member.type === 'felt') {
-        return acc + 1;
-      }
-      return acc + this.calculateStructMembers(member.type);
-    }, 0);
-  }
-
   /**
    * Deep parse of the object that has been passed to the method
    *
@@ -539,112 +630,4 @@ export class Contract implements ContractInterface {
       return acc;
     }, [] as Result);
   }
-
-  public invoke(
-    method: string,
-    args: Array<any> = [],
-    options: Overrides = {}
-  ): Promise<InvokeFunctionResponse> {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-    // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
-
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    const inputsLength = inputs.reduce((acc, input) => {
-      if (!/_len$/.test(input.name)) {
-        return acc + 1;
-      }
-      return acc;
-    }, 0);
-
-    if (args.length !== inputsLength) {
-      throw Error(
-        `Invalid number of arguments, expected ${inputsLength} arguments, but got ${args.length}`
-      );
-    }
-    // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
-
-    const invocation = {
-      contractAddress: this.address,
-      calldata,
-      entrypoint: method,
-    };
-    if ('execute' in this.providerOrAccount) {
-      return this.providerOrAccount.execute(invocation, undefined, {
-        maxFee: options.maxFee,
-        nonce: options.nonce,
-      });
-    }
-
-    if (!options.nonce) {
-      throw new Error(`Nonce is required when invoking a function without an account`);
-    }
-
-    // eslint-disable-next-line no-console
-    console.warn(`Invoking ${method} without an account. This will not work on a public node.`);
-
-    return this.providerOrAccount.invokeFunction(
-      {
-        ...invocation,
-        signature: options.signature || [],
-      },
-      {
-        nonce: options.nonce,
-      }
-    );
-  }
-
-  public async call(
-    method: string,
-    args: Array<any> = [],
-    {
-      blockIdentifier = 'pending',
-    }: {
-      blockIdentifier?: BlockIdentifier;
-    } = {}
-  ): Promise<Result> {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-
-    // validate method and args
-    this.validateMethodAndArgs('CALL', method, args);
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-
-    // compile calldata
-    const calldata = this.compileCalldata(args, inputs);
-    return this.providerOrAccount
-      .callContract(
-        {
-          contractAddress: this.address,
-          calldata,
-          entrypoint: method,
-        },
-        blockIdentifier
-      )
-      .then((x) => this.parseResponse(method, x.result));
-  }
-
-  public async estimate(method: string, args: Array<any> = []) {
-    // ensure contract is connected
-    assert(this.address !== null, 'contract is not connected to an address');
-
-    // validate method and args
-    this.validateMethodAndArgs('INVOKE', method, args);
-    const invocation = this.populateTransaction[method](...args);
-    if ('estimateInvokeFee' in this.providerOrAccount) {
-      return this.providerOrAccount.estimateInvokeFee(invocation);
-    }
-    throw Error('Contract must be connected to the account contract to estimate');
-  }
-
-  public populate(method: string, args: Array<any> = []): Call {
-    const { inputs } = this.abi.find((abi) => abi.name === method) as FunctionAbi;
-    return {
-      contractAddress: this.address,
-      entrypoint: method,
-      calldata: this.compileCalldata(args, inputs),
-    };
-  }
 }

package/src/contract/interface.ts

@@ -57,6 +57,7 @@ export abstract class ContractInterface {
    *
    * @param method name of the method
    * @param args Array of the arguments for the call
+   * @param options optional blockIdentifier
    * @returns Result of the call as an array with key value pars
    */
   public abstract call(
@@ -72,6 +73,7 @@ export abstract class ContractInterface {
    *
    * @param method name of the method
    * @param args Array of the arguments for the invoke
+   * @param options
    * @returns Add Transaction Response
    */
   public abstract invoke(
@@ -81,10 +83,11 @@ export abstract class ContractInterface {
   ): Promise<InvokeFunctionResponse>;
 
   /**
-   * Calls a method on a contract
+   * Estimates a method on a contract
    *
    * @param method name of the method
    * @param args Array of the arguments for the call
+   * @param options optional blockIdentifier
    */
   public abstract estimate(
     method: string,
@@ -99,7 +102,7 @@ export abstract class ContractInterface {
    *
    * @param method name of the method
    * @param args Array of the arguments for the call
-   * @returns Invocation objet
+   * @returns Invocation object
    */
   public abstract populate(method: string, args?: Array<any>): Invocation;
 }

package/src/provider/default.ts

@@ -15,7 +15,11 @@ import {
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
-import { DeclareContractTransaction, DeployAccountContractTransaction } from '../types/lib';
+import {
+  DeclareContractTransaction,
+  DeployAccountContractTransaction,
+  InvocationsDetails,
+} from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProvider, RpcProviderOptions } from './rpc';
@@ -61,6 +65,17 @@ export class Provider implements ProviderInterface {
     return this.provider.getClassAt(contractAddress, blockIdentifier);
   }
 
+  public async getClassHashAt(
+    contractAddress: string,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<string> {
+    return this.provider.getClassHashAt(contractAddress, blockIdentifier);
+  }
+
+  public getClass(classHash: string): Promise<ContractClass> {
+    return this.provider.getClass(classHash);
+  }
+
   public async getEstimateFee(
     invocationWithTxType: Invocation,
     invocationDetails: InvocationsDetailsWithNonce,
@@ -118,8 +133,11 @@ export class Provider implements ProviderInterface {
     return this.provider.invokeFunction(functionInvocation, details);
   }
 
-  public async deployContract(payload: DeployContractPayload): Promise<DeployContractResponse> {
-    return this.provider.deployContract(payload);
+  public async deployContract(
+    payload: DeployContractPayload,
+    details: InvocationsDetails
+  ): Promise<DeployContractResponse> {
+    return this.provider.deployContract(payload, details);
   }
 
   public async deployAccountContract(

package/src/provider/interface.ts

@@ -19,6 +19,7 @@ import {
   DeclareContractTransaction,
   DeployAccountContractPayload,
   DeployAccountContractTransaction,
+  InvocationsDetails,
 } from '../types/lib';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
@@ -73,6 +74,26 @@ export abstract class ProviderInterface {
     blockIdentifier?: BlockIdentifier
   ): Promise<ContractClass>;
 
+  /**
+   * Returns the class hash deployed under the given address.
+   *
+   * @param contractAddress - contract address
+   * @param blockIdentifier - block identifier
+   * @returns Class hash
+   */
+  public abstract getClassHashAt(
+    contractAddress: string,
+    blockIdentifier?: BlockIdentifier
+  ): Promise<string>;
+
+  /**
+   * Returns the contract class deployed under the given class hash.
+   *
+   * @param classHash - class hash
+   * @returns Contract class of compiled contract
+   */
+  public abstract getClass(classHash: string): Promise<ContractClass>;
+
   /**
    * Gets the nonce of a contract with respect to a specific block
    *
@@ -95,7 +116,7 @@ export abstract class ProviderInterface {
   public abstract getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockIdentifier: BlockIdentifier
+    blockIdentifier?: BlockIdentifier
   ): Promise<BigNumberish>;
 
   /**
@@ -125,7 +146,10 @@ export abstract class ProviderInterface {
    * - address salt
    * @returns a confirmation of sending a transaction on the starknet contract
    */
-  public abstract deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
+  public abstract deployContract(
+    payload: DeployContractPayload,
+    details?: InvocationsDetails
+  ): Promise<DeployContractResponse>;
 
   /**
    * Deploys a given compiled Account contract (json) to starknet