starknet 4.7.0 → 4.9.0

package/src/account/default.ts

@@ -6,6 +6,9 @@ import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
   Call,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeAction,
   InvocationsDetails,
   InvocationsSignerDetails,
   InvokeFunctionResponse,
@@ -13,8 +16,10 @@ import {
   Signature,
 } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { transactionVersion } from '../utils/hash';
+import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
+import { calculateContractAddressFromHash, transactionVersion } from '../utils/hash';
 import { BigNumberish, toBN } 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 +46,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 +72,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 +86,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 +192,98 @@ 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 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 +300,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,16 @@ import { SignerInterface } from '../signer';
 import {
   Abi,
   Call,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeAction,
   EstimateFeeDetails,
   EstimateFeeResponse,
   InvocationsDetails,
   InvokeFunctionResponse,
   Signature,
 } from '../types';
+import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
@@ -19,18 +23,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 declared
+   * - 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 +94,46 @@ 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>;
+
+  /**
+   * 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
+   * @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
@@ -93,5 +175,21 @@ 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

@@ -15,6 +15,7 @@ export enum StarknetChainId {
 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'),
 }

package/src/contract/default.ts

@@ -125,7 +125,7 @@ export class Contract implements ContractInterface {
     address: string,
     providerOrAccount: ProviderInterface | AccountInterface = defaultProvider
   ) {
-    this.address = address.toLowerCase();
+    this.address = address && address.toLowerCase();
     this.providerOrAccount = providerOrAccount;
     this.abi = abi;
     this.structs = abi
@@ -546,7 +546,7 @@ export class Contract implements ContractInterface {
     options: Overrides = {}
   ): Promise<InvokeFunctionResponse> {
     // ensure contract is connected
-    assert(this.address !== null, 'contract isnt connected to an address');
+    assert(this.address !== null, 'contract is not connected to an address');
     // validate method and args
     this.validateMethodAndArgs('INVOKE', method, args);
 
@@ -606,7 +606,7 @@ export class Contract implements ContractInterface {
     } = {}
   ): Promise<Result> {
     // ensure contract is connected
-    assert(this.address !== null, 'contract isnt connected to an address');
+    assert(this.address !== null, 'contract is not connected to an address');
 
     // validate method and args
     this.validateMethodAndArgs('CALL', method, args);
@@ -628,13 +628,13 @@ export class Contract implements ContractInterface {
 
   public async estimate(method: string, args: Array<any> = []) {
     // ensure contract is connected
-    assert(this.address !== null, 'contract isnt connected to an address');
+    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 ('estimateFee' in this.providerOrAccount) {
-      return this.providerOrAccount.estimateFee(invocation);
+    if ('estimateInvokeFee' in this.providerOrAccount) {
+      return this.providerOrAccount.estimateInvokeFee(invocation);
     }
     throw Error('Contract must be connected to the account contract to estimate');
   }

package/src/provider/default.ts

@@ -3,7 +3,6 @@ import {
   Call,
   CallContractResponse,
   ContractClass,
-  DeclareContractPayload,
   DeclareContractResponse,
   DeployContractPayload,
   DeployContractResponse,
@@ -16,6 +15,7 @@ import {
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
+import { DeclareContractTransaction, DeployAccountContractTransaction } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProvider, RpcProviderOptions } from './rpc';
@@ -62,11 +62,23 @@ export class Provider implements ProviderInterface {
   }
 
   public async getEstimateFee(
-    invocation: Invocation,
+    invocationWithTxType: Invocation,
     invocationDetails: InvocationsDetailsWithNonce,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
-    return this.provider.getEstimateFee(invocation, invocationDetails, blockIdentifier);
+    return this.provider.getEstimateFee(invocationWithTxType, invocationDetails, blockIdentifier);
+  }
+
+  public async getInvokeEstimateFee(
+    invocationWithTxType: Invocation,
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.provider.getInvokeEstimateFee(
+      invocationWithTxType,
+      invocationDetails,
+      blockIdentifier
+    );
   }
 
   public async getNonce(
@@ -110,8 +122,34 @@ export class Provider implements ProviderInterface {
     return this.provider.deployContract(payload);
   }
 
-  public async declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse> {
-    return this.provider.declareContract(payload);
+  public async deployAccountContract(
+    payload: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeployContractResponse> {
+    return this.provider.deployAccountContract(payload, details);
+  }
+
+  public async declareContract(
+    transaction: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeclareContractResponse> {
+    return this.provider.declareContract(transaction, details);
+  }
+
+  public async getDeclareEstimateFee(
+    transaction: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.provider.getDeclareEstimateFee(transaction, details, blockIdentifier);
+  }
+
+  public getDeployAccountEstimateFee(
+    transaction: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.provider.getDeployAccountEstimateFee(transaction, details, blockIdentifier);
   }
 
   public async getCode(