starknet 4.8.0 → 4.10.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';
@@ -6,6 +6,9 @@ import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
   Call,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeAction,
   InvocationsDetails,
   InvocationsSignerDetails,
   InvokeFunctionResponse,
@@ -13,8 +16,15 @@ import {
   Signature,
 } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { transactionVersion } from '../utils/hash';
-import { BigNumberish, toBN } from '../utils/number';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
+import { calculateContractAddressFromHash, 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';
 import { TypedData, getMessageHash } from '../utils/typedData';
@@ -41,7 +51,14 @@ export class Account extends Provider implements AccountInterface {
   }
 
   public async estimateFee(
-    calls: Call | Call[],
+    calls: AllowArray<Call>,
+    estimateFeeDetails?: EstimateFeeDetails | undefined
+  ): Promise<EstimateFee> {
+    return this.estimateInvokeFee(calls, estimateFeeDetails);
+  }
+
+  public async estimateInvokeFee(
+    calls: AllowArray<Call>,
     { nonce: providedNonce, blockIdentifier }: EstimateFeeDetails = {}
   ): Promise<EstimateFee> {
     const transactions = Array.isArray(calls) ? calls : [calls];
@@ -60,7 +77,7 @@ export class Account extends Provider implements AccountInterface {
     const signature = await this.signer.signTransaction(transactions, signerDetails);
 
     const calldata = fromCallsToExecuteCalldata(transactions);
-    const response = await super.getEstimateFee(
+    const response = await super.getInvokeEstimateFee(
       { contractAddress: this.address, calldata, signature },
       { version, nonce },
       blockIdentifier
@@ -74,31 +91,87 @@ export class Account extends Provider implements AccountInterface {
     };
   }
 
-  /**
-   * Invoke execute function in account contract
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-   *
-   * @param calls - one or more calls to be executed
-   * @param abis - one or more abis which can be used to display the calls
-   * @param transactionsDetail - optional transaction details
-   * @returns a confirmation of invoking a function on the starknet contract
-   */
+  public async estimateDeclareFee(
+    { classHash, contract }: DeclareContractPayload,
+    { blockIdentifier, nonce: providedNonce }: EstimateFeeDetails = {}
+  ): Promise<EstimateFee> {
+    const nonce = toBN(providedNonce ?? (await this.getNonce()));
+    const version = toBN(transactionVersion);
+    const chainId = await this.getChainId();
+    const contractDefinition = parseContract(contract);
+
+    const signature = await this.signer.signDeclareTransaction({
+      classHash,
+      senderAddress: this.address,
+      chainId,
+      maxFee: ZERO,
+      version,
+      nonce,
+    });
+
+    const response = await super.getDeclareEstimateFee(
+      { senderAddress: this.address, signature, contractDefinition },
+      { version, nonce },
+      blockIdentifier
+    );
+    const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
+
+    return {
+      ...response,
+      suggestedMaxFee,
+    };
+  }
+
+  public async estimateAccountDeployFee(
+    {
+      classHash,
+      addressSalt = 0,
+      constructorCalldata = [],
+      contractAddress: providedContractAddress,
+    }: DeployAccountContractPayload,
+    { blockIdentifier, nonce: providedNonce }: EstimateFeeDetails = {}
+  ): Promise<EstimateFee> {
+    const nonce = toBN(providedNonce ?? (await this.getNonce()));
+    const version = toBN(transactionVersion);
+    const chainId = await this.getChainId();
+    const contractAddress =
+      providedContractAddress ??
+      calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+
+    const signature = await this.signer.signDeployAccountTransaction({
+      classHash,
+      contractAddress,
+      chainId,
+      maxFee: ZERO,
+      version,
+      nonce,
+      addressSalt,
+      constructorCalldata,
+    });
+
+    const response = await super.getDeployAccountEstimateFee(
+      { classHash, addressSalt, constructorCalldata, signature },
+      { version, nonce },
+      blockIdentifier
+    );
+    const suggestedMaxFee = estimatedFeeToMaxFee(response.overall_fee);
+
+    return {
+      ...response,
+      suggestedMaxFee,
+    };
+  }
+
   public async execute(
-    calls: Call | Call[],
+    calls: AllowArray<Call>,
     abis: Abi[] | undefined = undefined,
     transactionsDetail: InvocationsDetails = {}
   ): Promise<InvokeFunctionResponse> {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
-    let maxFee: BigNumberish = '0';
-    if (transactionsDetail.maxFee || transactionsDetail.maxFee === 0) {
-      maxFee = transactionsDetail.maxFee;
-    } else {
-      const { suggestedMaxFee } = await this.estimateFee(transactions, { nonce });
-      maxFee = suggestedMaxFee.toString();
-    }
-
+    const maxFee =
+      transactionsDetail.maxFee ??
+      (await this.getSuggestedMaxFee({ type: 'INVOKE', payload: calls }, transactionsDetail));
     const version = toBN(transactionVersion);
     const chainId = await this.getChainId();
 
@@ -124,37 +197,133 @@ export class Account extends Provider implements AccountInterface {
     );
   }
 
-  /**
-   * Sign an JSON object with the starknet private key and return the signature
-   *
-   * @param json - JSON object to be signed
-   * @returns the signature of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
+  public async declare(
+    { classHash, contract }: DeclareContractPayload,
+    transactionsDetail: InvocationsDetails = {}
+  ): Promise<DeclareContractResponse> {
+    const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
+    const maxFee =
+      transactionsDetail.maxFee ??
+      (await this.getSuggestedMaxFee(
+        { type: 'DECLARE', payload: { classHash, contract } },
+        transactionsDetail
+      ));
+
+    const version = toBN(transactionVersion);
+    const chainId = await this.getChainId();
+
+    const signature = await this.signer.signDeclareTransaction({
+      classHash,
+      senderAddress: this.address,
+      chainId,
+      maxFee,
+      version,
+      nonce,
+    });
+
+    const contractDefinition = parseContract(contract);
+
+    return this.declareContract(
+      { contractDefinition, senderAddress: this.address, signature },
+      {
+        nonce,
+        maxFee,
+        version,
+      }
+    );
+  }
+
+  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,
+      constructorCalldata = [],
+      addressSalt = 0,
+      contractAddress: providedContractAddress,
+    }: DeployAccountContractPayload,
+    transactionsDetail: InvocationsDetails = {}
+  ): Promise<DeployContractResponse> {
+    const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
+    const version = toBN(transactionVersion);
+    const chainId = await this.getChainId();
+
+    const contractAddress =
+      providedContractAddress ??
+      calculateContractAddressFromHash(addressSalt, classHash, constructorCalldata, 0);
+
+    const maxFee =
+      transactionsDetail.maxFee ??
+      (await this.getSuggestedMaxFee(
+        {
+          type: 'DEPLOY_ACCOUNT',
+          payload: { classHash, constructorCalldata, addressSalt, contractAddress },
+        },
+        transactionsDetail
+      ));
+
+    const signature = await this.signer.signDeployAccountTransaction({
+      classHash,
+      constructorCalldata,
+      contractAddress,
+      addressSalt,
+      chainId,
+      maxFee,
+      version,
+      nonce,
+    });
+
+    return this.deployAccountContract(
+      { classHash, addressSalt, constructorCalldata, signature },
+      {
+        nonce,
+        maxFee,
+        version,
+      }
+    );
+  }
+
   public async signMessage(typedData: TypedData): Promise<Signature> {
     return this.signer.signMessage(typedData, this.address);
   }
 
-  /**
-   * Hash a JSON object with pederson hash and return the hash
-   *
-   * @param json - JSON object to be hashed
-   * @returns the hash of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
   public async hashMessage(typedData: TypedData): Promise<string> {
     return getMessageHash(typedData, this.address);
   }
 
-  /**
-   * Verify a signature of a given hash
-   * @warning This method is not recommended, use verifyMessage instead
-   *
-   * @param hash - 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
-   */
   public async verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean> {
     try {
       await this.callContract({
@@ -171,16 +340,35 @@ export class Account extends Provider implements AccountInterface {
     }
   }
 
-  /**
-   * Verify a signature of a JSON object
-   *
-   * @param hash - hash to be verified
-   * @param signature - signature of the hash
-   * @returns true if the signature is valid, false otherwise
-   * @throws {Error} if the signature is not a valid signature
-   */
   public async verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean> {
     const hash = await this.hashMessage(typedData);
     return this.verifyMessageHash(hash, signature);
   }
+
+  public async getSuggestedMaxFee(
+    estimateFeeAction: EstimateFeeAction,
+    details: EstimateFeeDetails
+  ) {
+    let feeEstimate: EstimateFee;
+
+    switch (estimateFeeAction.type) {
+      case 'INVOKE':
+        feeEstimate = await this.estimateInvokeFee(estimateFeeAction.payload, details);
+        break;
+
+      case 'DECLARE':
+        feeEstimate = await this.estimateDeclareFee(estimateFeeAction.payload, details);
+        break;
+
+      case 'DEPLOY_ACCOUNT':
+        feeEstimate = await this.estimateAccountDeployFee(estimateFeeAction.payload, details);
+        break;
+
+      default:
+        feeEstimate = { suggestedMaxFee: ZERO, overall_fee: ZERO };
+        break;
+    }
+
+    return feeEstimate.suggestedMaxFee.toString();
+  }
 }

package/src/account/interface.ts

@@ -4,12 +4,21 @@ import { SignerInterface } from '../signer';
 import {
   Abi,
   Call,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeAction,
   EstimateFeeDetails,
   EstimateFeeResponse,
   InvocationsDetails,
   InvokeFunctionResponse,
   Signature,
 } from '../types';
+import {
+  AllowArray,
+  DeclareContractPayload,
+  DeployAccountContractPayload,
+  UniversalDeployerContractPayload,
+} from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
@@ -19,18 +28,61 @@ export abstract class AccountInterface extends ProviderInterface {
   public abstract signer: SignerInterface;
 
   /**
-   * Estimate Fee for a method on starknet
+   * @deprecated Use estimateInvokeFee or estimateDeclareFee instead
+   * Estimate Fee for executing an INVOKE transaction on starknet
    *
-   * @param invocation the invocation object containing:
+   * @param calls the invocation object containing:
    * - contractAddress - the address of the contract
    * - entrypoint - the entrypoint of the contract
    * - calldata - (defaults to []) the calldata
-   * - signature - (defaults to []) the signature
    *
-   * @returns response from addTransaction
+   * @returns response from estimate_fee
    */
   public abstract estimateFee(
-    calls: Call | Call[],
+    calls: AllowArray<Call>,
+    estimateFeeDetails?: EstimateFeeDetails
+  ): Promise<EstimateFeeResponse>;
+
+  /**
+   * Estimate Fee for executing an INVOKE transaction on starknet
+   *
+   * @param calls the invocation object containing:
+   * - contractAddress - the address of the contract
+   * - entrypoint - the entrypoint of the contract
+   * - calldata - (defaults to []) the calldata
+   *
+   * @returns response from estimate_fee
+   */
+  public abstract estimateInvokeFee(
+    calls: AllowArray<Call>,
+    estimateFeeDetails?: EstimateFeeDetails
+  ): Promise<EstimateFeeResponse>;
+
+  /**
+   * Estimate Fee for executing a DECLARE transaction on starknet
+   *
+   * @param contractPayload the payload object containing:
+   * - contract - the compiled contract to be declared
+   * - classHash - the class hash of the compiled contract. This can be obtained by using starknet-cli.
+   *
+   * @returns response from estimate_fee
+   */
+  public abstract estimateDeclareFee(
+    contractPayload: DeclareContractPayload,
+    estimateFeeDetails?: EstimateFeeDetails
+  ): Promise<EstimateFeeResponse>;
+
+  /**
+   * Estimate Fee for executing a DEPLOY_ACCOUNT transaction on starknet
+   *
+   * @param contractPayload the payload object containing:
+   * - 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
+   */
+  public abstract estimateAccountDeployFee(
+    contractPayload: DeployAccountContractPayload,
     estimateFeeDetails?: EstimateFeeDetails
   ): Promise<EstimateFeeResponse>;
 
@@ -47,11 +99,66 @@ export abstract class AccountInterface extends ProviderInterface {
    * @returns response from addTransaction
    */
   public abstract execute(
-    transactions: Call | Call[],
+    transactions: AllowArray<Call>,
     abis?: Abi[],
     transactionsDetail?: InvocationsDetails
   ): Promise<InvokeFunctionResponse>;
 
+  /**
+   * 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
+  - signature
+   * @param transactionsDetail Invocation Details containing:
+  - optional nonce
+  - optional version
+  - optional maxFee
+   * @returns a confirmation of sending a transaction on the starknet contract
+   */
+  public abstract declare(
+    contractPayload: DeclareContractPayload,
+    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
+  - optional constructor calldata
+  - optional address salt  
+  - optional contractAddress
+   * @param transactionsDetail Invocation Details containing:
+  - optional nonce
+  - optional version
+  - optional maxFee
+   * @returns a confirmation of sending a transaction on the starknet contract
+   */
+  public abstract deployAccount(
+    contractPayload: DeployAccountContractPayload,
+    transactionsDetail?: InvocationsDetails
+  ): Promise<DeployContractResponse>;
+
   /**
    * Sign an JSON object for off-chain usage with the starknet private key and return the signature
    * This adds a message prefix so it cant be interchanged with transactions
@@ -75,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
@@ -93,5 +200,23 @@ export abstract class AccountInterface extends ProviderInterface {
    */
   public abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
 
+  /**
+   * 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
+   */
   public abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
+
+  /**
+   * Gets Suggested Max Fee based on the transaction type
+   *
+   * @param  {EstimateFeeAction} estimateFeeAction
+   * @param  {EstimateFeeDetails} details
+   * @returns suggestedMaxFee
+   */
+  public abstract getSuggestedMaxFee(
+    estimateFeeAction: EstimateFeeAction,
+    details: EstimateFeeDetails
+  ): Promise<BigNumberish>;
 }

package/src/constants.ts

@@ -11,14 +11,22 @@ 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'),
   DEPLOY = '0x6465706c6f79', // encodeShortString('deploy'),
+  DEPLOY_ACCOUNT = '0x6465706c6f795f6163636f756e74', // encodeShortString('deploy_account'),
   INVOKE = '0x696e766f6b65', // encodeShortString('invoke'),
   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.