starknet 4.8.0 → 4.10.0

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
@@ -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 isnt 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 isnt 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 isnt 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);
-    }
-    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

@@ -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(

package/src/provider/interface.ts

@@ -3,7 +3,6 @@ import type {
   Call,
   CallContractResponse,
   ContractClass,
-  DeclareContractPayload,
   DeclareContractResponse,
   DeployContractPayload,
   DeployContractResponse,
@@ -16,6 +15,11 @@ import type {
   InvocationsDetailsWithNonce,
   InvokeFunctionResponse,
 } from '../types';
+import {
+  DeclareContractTransaction,
+  DeployAccountContractPayload,
+  DeployAccountContractTransaction,
+} from '../types/lib';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 
@@ -124,16 +128,18 @@ export abstract class ProviderInterface {
   public abstract deployContract(payload: DeployContractPayload): Promise<DeployContractResponse>;
 
   /**
-   * Declares a given compiled contract (json) to starknet
+   * Deploys a given compiled Account contract (json) to starknet
    *
    * @param payload payload to be deployed containing:
    * - compiled contract code
-   * - optional version
+   * - constructor calldata
+   * - address salt
    * @returns a confirmation of sending a transaction on the starknet contract
    */
-  public abstract declareContract(
-    payload: DeclareContractPayload
-  ): Promise<DeclareContractResponse>;
+  public abstract deployAccountContract(
+    payload: DeployAccountContractPayload,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeployContractResponse>;
 
   /**
    * Invokes a function on starknet
@@ -156,7 +162,25 @@ export abstract class ProviderInterface {
   ): Promise<InvokeFunctionResponse>;
 
   /**
-   * Estimates the fee for a given transaction
+   * Declares a given compiled contract (json) to starknet
+   * @param transaction transaction payload to be deployed containing:
+   * - compiled contract code
+   * - sender address
+   * - signature
+   * @param details Invocation Details containing:
+   * - nonce
+   * - optional version
+   * - optional maxFee
+   * @returns a confirmation of sending a transaction on the starknet contract
+   */
+  public abstract declareContract(
+    transaction: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeclareContractResponse>;
+
+  /**
+   * Estimates the fee for a given INVOKE transaction
+   * @deprecated Please use getInvokeEstimateFee or getDeclareEstimateFee instead
    *
    * @param invocation the invocation object containing:
    * - contractAddress - the address of the contract
@@ -175,6 +199,67 @@ export abstract class ProviderInterface {
     blockIdentifier: BlockIdentifier
   ): Promise<EstimateFeeResponse>;
 
+  /**
+   * Estimates the fee for a given INVOKE transaction
+   *
+   * @param invocation 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
+   * @param blockIdentifier - block identifier
+   * @param details - optional details containing:
+   * - nonce - optional nonce
+   * - version - optional version
+   * @returns the estimated fee
+   */
+  public abstract getInvokeEstimateFee(
+    invocation: Invocation,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier
+  ): Promise<EstimateFeeResponse>;
+
+  /**
+   * Estimates the fee for a given DECLARE transaction
+   *
+   * @param transaction transaction payload to be declared containing:
+   * - compiled contract code
+   * - sender address
+   * - signature - (defaults to []) the signature
+   * @param details - optional details containing:
+   * - nonce
+   * - version - optional version
+   * - optional maxFee
+   * @param blockIdentifier - block identifier
+   * @returns the estimated fee
+   */
+  public abstract getDeclareEstimateFee(
+    transaction: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier
+  ): Promise<EstimateFeeResponse>;
+
+  /**
+   * Estimates the fee for a given DEPLOY_ACCOUNT transaction
+   *
+   * @param transaction transaction payload to be deployed containing:
+   * - classHash
+   * - constructorCalldata
+   * - addressSalt
+   * - signature - (defaults to []) the signature
+   * @param details - optional details containing:
+   * - nonce
+   * - version - optional version
+   * - optional maxFee
+   * @param blockIdentifier - block identifier
+   * @returns the estimated fee
+   */
+  public abstract getDeployAccountEstimateFee(
+    transaction: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier
+  ): Promise<EstimateFeeResponse>;
+
   /**
    * Wait for the transaction to be accepted
    * @param txHash - transaction hash