starknet 4.7.0 → 4.9.0

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

package/src/provider/rpc.ts

@@ -2,7 +2,6 @@ import { StarknetChainId } from '../constants';
 import {
   Call,
   CallContractResponse,
-  DeclareContractPayload,
   DeclareContractResponse,
   DeployContractPayload,
   DeployContractResponse,
@@ -16,6 +15,11 @@ import {
   InvokeFunctionResponse,
 } from '../types';
 import { RPC } from '../types/api';
+import {
+  DeclareContractTransaction,
+  DeployAccountContractPayload,
+  DeployAccountContractTransaction,
+} from '../types/lib';
 import fetch from '../utils/fetchPonyfill';
 import { getSelectorFromName } from '../utils/hash';
 import { stringify } from '../utils/json';
@@ -183,9 +187,7 @@ export class RpcProvider implements ProviderInterface {
   }
 
   public async getTransactionReceipt(txHash: string): Promise<GetTransactionReceiptResponse> {
-    return this.fetchEndpoint('starknet_getTransactionReceipt', { transaction_hash: txHash }).then(
-      this.responseParser.parseGetTransactionReceiptResponse
-    );
+    return this.fetchEndpoint('starknet_getTransactionReceipt', { transaction_hash: txHash });
   }
 
   public async getClass(classHash: RPC.Felt): Promise<RPC.ContractClass> {
@@ -214,33 +216,93 @@ export class RpcProvider implements ProviderInterface {
     invocation: Invocation,
     invocationDetails: InvocationsDetailsWithNonce,
     blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+  }
+
+  public async getInvokeEstimateFee(
+    invocation: Invocation,
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_estimateFee', {
       request: {
+        type: 'INVOKE',
         contract_address: invocation.contractAddress,
         calldata: parseCalldata(invocation.calldata),
         signature: bigNumberishArrayToHexadecimalStringArray(invocation.signature || []),
         version: toHex(toBN(invocationDetails?.version || 0)),
+        nonce: toHex(toBN(invocationDetails.nonce)),
         max_fee: toHex(toBN(invocationDetails?.maxFee || 0)),
       },
       block_id,
     }).then(this.responseParser.parseFeeEstimateResponse);
   }
 
-  public async declareContract({
-    contract,
-    version,
-  }: DeclareContractPayload): Promise<DeclareContractResponse> {
-    const contractDefinition = parseContract(contract);
+  // TODO: Revisit after Pathfinder release with JSON-RPC v0.2.1 RPC Spec
+
+  public async getDeclareEstimateFee(
+    { senderAddress, contractDefinition, signature }: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_estimateFee', {
+      request: {
+        type: 'DECLARE',
+        contract_class: {
+          program: contractDefinition.program,
+          entry_points_by_type: contractDefinition.entry_points_by_type,
+          abi: contractDefinition.abi, // rpc 2.0
+        },
+        sender_address: senderAddress,
+        signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
+        version: toHex(toBN(details?.version || 0)),
+        nonce: toHex(toBN(details.nonce)),
+        max_fee: toHex(toBN(details?.maxFee || 0)),
+      },
+      block_id,
+    }).then(this.responseParser.parseFeeEstimateResponse);
+  }
 
+  public async getDeployAccountEstimateFee(
+    { classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    const block_id = new Block(blockIdentifier).identifier;
+    return this.fetchEndpoint('starknet_estimateFee', {
+      request: {
+        type: 'DEPLOY_ACCOUNT',
+        constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+        class_hash: toHex(toBN(classHash)),
+        contract_address_salt: toHex(toBN(addressSalt || 0)),
+        signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
+        version: toHex(toBN(details?.version || 0)),
+        nonce: toHex(toBN(details.nonce)),
+        max_fee: toHex(toBN(details?.maxFee || 0)),
+      },
+      block_id,
+    }).then(this.responseParser.parseFeeEstimateResponse);
+  }
+
+  // TODO: Revisit after Pathfinder release with JSON-RPC v0.2.1 RPC Spec
+  public async declareContract(
+    { contractDefinition, signature, senderAddress }: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeclareContractResponse> {
     return this.fetchEndpoint('starknet_addDeclareTransaction', {
       contract_class: {
         program: contractDefinition.program,
         entry_points_by_type: contractDefinition.entry_points_by_type,
         abi: contractDefinition.abi, // rpc 2.0
       },
-      version: toHex(toBN(version || 0)),
+      version: toHex(toBN(details.version || 0)),
+      max_fee: toHex(toBN(details.maxFee || 0)),
+      signature: bigNumberishArrayToHexadecimalStringArray(signature || []),
+      sender_address: senderAddress,
+      nonce: toHex(toBN(details.nonce)),
     });
   }
 
@@ -262,6 +324,18 @@ export class RpcProvider implements ProviderInterface {
     });
   }
 
+  public async deployAccountContract({
+    classHash,
+    constructorCalldata,
+    addressSalt,
+  }: DeployAccountContractPayload): Promise<DeployContractResponse> {
+    return this.fetchEndpoint('starknet_addDeployAccountTransaction', {
+      constructor_calldata: bigNumberishArrayToHexadecimalStringArray(constructorCalldata || []),
+      class_hash: toHex(toBN(classHash)),
+      contract_address_salt: toHex(toBN(addressSalt || 0)),
+    });
+  }
+
   public async invokeFunction(
     functionInvocation: Invocation,
     details: InvocationsDetailsWithNonce
@@ -317,9 +391,9 @@ export class RpcProvider implements ProviderInterface {
         // eslint-disable-next-line no-await-in-loop
         const res = await this.getTransactionReceipt(txHash);
 
-        if (successStates.includes(res.status)) {
+        if (res.status && successStates.includes(res.status)) {
           onchain = true;
-        } else if (errorStates.includes(res.status)) {
+        } else if (res.status && errorStates.includes(res.status)) {
           const message = res.status;
           const error = new Error(message) as Error & { response: any };
           error.response = res;

package/src/provider/sequencer.ts

@@ -1,11 +1,10 @@
 import urljoin from 'url-join';
 
-import { ONE, StarknetChainId, ZERO } from '../constants';
+import { StarknetChainId } from '../constants';
 import {
   Call,
   CallContractResponse,
   ContractClass,
-  DeclareContractPayload,
   DeclareContractResponse,
   DeployContractPayload,
   DeployContractResponse,
@@ -18,15 +17,25 @@ import {
   InvokeFunctionResponse,
 } from '../types';
 import {
+  CallL1Handler,
   GetContractAddressesResponse,
   GetTransactionStatusResponse,
   GetTransactionTraceResponse,
   Sequencer,
 } from '../types/api';
+import { DeclareContractTransaction, DeployAccountContractTransaction } from '../types/lib';
 import fetch from '../utils/fetchPonyfill';
-import { getSelectorFromName } from '../utils/hash';
+import { getSelector, getSelectorFromName } from '../utils/hash';
 import { parse, parseAlwaysAsBig, stringify } from '../utils/json';
-import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
+import {
+  BigNumberish,
+  bigNumberishArrayToDecimalStringArray,
+  getDecimalString,
+  getHexString,
+  getHexStringArray,
+  toBN,
+  toHex,
+} from '../utils/number';
 import { parseContract, wait } from '../utils/provider';
 import { SequencerAPIResponseParser } from '../utils/responseParser/sequencer';
 import { randomAddress } from '../utils/stark';
@@ -117,7 +126,12 @@ export class SequencerProvider implements ProviderInterface {
   }
 
   private getFetchMethod(endpoint: keyof Sequencer.Endpoints) {
-    const postMethodEndpoints = ['add_transaction', 'call_contract', 'estimate_fee'];
+    const postMethodEndpoints = [
+      'add_transaction',
+      'call_contract',
+      'estimate_fee',
+      'estimate_message_fee',
+    ];
 
     return postMethodEndpoints.includes(endpoint) ? 'POST' : 'GET';
   }
@@ -151,7 +165,7 @@ export class SequencerProvider implements ProviderInterface {
   // typesafe fetch
   protected async fetchEndpoint<T extends keyof Sequencer.Endpoints>(
     endpoint: T,
-    // typescript type magiuc to create a nice fitting function interface
+    // typescript type magic to create a nice fitting function interface
     ...[query, request]: Sequencer.Endpoints[T]['QUERY'] extends never
       ? Sequencer.Endpoints[T]['REQUEST'] extends never
         ? [] // when no query and no request is needed, we can omit the query and request parameters
@@ -307,17 +321,34 @@ export class SequencerProvider implements ProviderInterface {
     }).then(this.responseParser.parseDeployContractResponse);
   }
 
-  public async declareContract({
-    contract,
-  }: DeclareContractPayload): Promise<DeclareContractResponse> {
-    const contractDefinition = parseContract(contract);
+  public async deployAccountContract(
+    { classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeployContractResponse> {
+    return this.fetchEndpoint('add_transaction', undefined, {
+      type: 'DEPLOY_ACCOUNT',
+      contract_address_salt: addressSalt ?? randomAddress(),
+      constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata ?? []),
+      class_hash: toHex(toBN(classHash)),
+      max_fee: toHex(toBN(details.maxFee || 0)),
+      version: toHex(toBN(details.version || 0)),
+      nonce: toHex(toBN(details.nonce)),
+      signature: bigNumberishArrayToDecimalStringArray(signature || []),
+    }).then(this.responseParser.parseDeployContractResponse);
+  }
 
+  public async declareContract(
+    { senderAddress, contractDefinition, signature }: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce
+  ): Promise<DeclareContractResponse> {
     return this.fetchEndpoint('add_transaction', undefined, {
       type: 'DECLARE',
       contract_class: contractDefinition,
-      nonce: toHex(ZERO),
-      signature: [],
-      sender_address: toHex(ONE),
+      nonce: toHex(toBN(details.nonce)),
+      signature: bigNumberishArrayToDecimalStringArray(signature || []),
+      sender_address: senderAddress,
+      max_fee: toHex(toBN(details.maxFee || 0)),
+      version: toHex(toBN(details.version || 1)),
     }).then(this.responseParser.parseDeclareContractResponse);
   }
 
@@ -325,6 +356,14 @@ export class SequencerProvider implements ProviderInterface {
     invocation: Invocation,
     invocationDetails: InvocationsDetailsWithNonce,
     blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.getInvokeEstimateFee(invocation, invocationDetails, blockIdentifier);
+  }
+
+  public async getInvokeEstimateFee(
+    invocation: Invocation,
+    invocationDetails: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<EstimateFeeResponse> {
     return this.fetchEndpoint(
       'estimate_fee',
@@ -340,6 +379,45 @@ export class SequencerProvider implements ProviderInterface {
     ).then(this.responseParser.parseFeeEstimateResponse);
   }
 
+  public async getDeclareEstimateFee(
+    { senderAddress, contractDefinition, signature }: DeclareContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.fetchEndpoint(
+      'estimate_fee',
+      { blockIdentifier },
+      {
+        type: 'DECLARE',
+        sender_address: senderAddress,
+        contract_class: contractDefinition,
+        signature: bigNumberishArrayToDecimalStringArray(signature || []),
+        version: toHex(toBN(details?.version || 1)),
+        nonce: toHex(toBN(details.nonce)),
+      }
+    ).then(this.responseParser.parseFeeEstimateResponse);
+  }
+
+  public async getDeployAccountEstimateFee(
+    { classHash, addressSalt, constructorCalldata, signature }: DeployAccountContractTransaction,
+    details: InvocationsDetailsWithNonce,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<EstimateFeeResponse> {
+    return this.fetchEndpoint(
+      'estimate_fee',
+      { blockIdentifier },
+      {
+        type: 'DEPLOY_ACCOUNT',
+        class_hash: toHex(toBN(classHash)),
+        constructor_calldata: bigNumberishArrayToDecimalStringArray(constructorCalldata || []),
+        contract_address_salt: toHex(toBN(addressSalt || 0)),
+        signature: bigNumberishArrayToDecimalStringArray(signature || []),
+        version: toHex(toBN(details?.version || 0)),
+        nonce: toHex(toBN(details.nonce)),
+      }
+    ).then(this.responseParser.parseFeeEstimateResponse);
+  }
+
   public async getCode(
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
@@ -406,4 +484,18 @@ export class SequencerProvider implements ProviderInterface {
     const txHashHex = toHex(toBN(txHash));
     return this.fetchEndpoint('get_transaction_trace', { transactionHash: txHashHex });
   }
+
+  public async estimateMessageFee(
+    { from_address, to_address, entry_point_selector, payload }: CallL1Handler,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<Sequencer.EstimateFeeResponse> {
+    const validCallL1Handler = {
+      from_address: getDecimalString(from_address),
+      to_address: getHexString(to_address),
+      entry_point_selector: getSelector(entry_point_selector),
+      payload: getHexStringArray(payload),
+    };
+
+    return this.fetchEndpoint('estimate_message_fee', { blockIdentifier }, validCallL1Handler);
+  }
 }

package/src/signer/default.ts

@@ -1,6 +1,18 @@
-import { Abi, Call, InvocationsSignerDetails, KeyPair, Signature } from '../types';
+import {
+  Abi,
+  Call,
+  DeclareSignerDetails,
+  InvocationsSignerDetails,
+  KeyPair,
+  Signature,
+} from '../types';
+import { DeployAccountSignerDetails } from '../types/signer';
 import { genKeyPair, getStarkKey, sign } from '../utils/ellipticCurve';
-import { calculateTransactionHash } from '../utils/hash';
+import {
+  calculateDeclareTransactionHash,
+  calculateDeployAccountTransactionHash,
+  calculateTransactionHash,
+} from '../utils/hash';
 import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
@@ -40,6 +52,46 @@ export class Signer implements SignerInterface {
     return sign(this.keyPair, msgHash);
   }
 
+  public async signDeclareTransaction(
+    // contractClass: ContractClass,  // Should be used once class hash is present in ContractClass
+    { classHash, senderAddress, chainId, maxFee, version, nonce }: DeclareSignerDetails
+  ) {
+    const msgHash = calculateDeclareTransactionHash(
+      classHash,
+      senderAddress,
+      version,
+      maxFee,
+      chainId,
+      nonce
+    );
+
+    return sign(this.keyPair, msgHash);
+  }
+
+  public async signDeployAccountTransaction({
+    classHash,
+    contractAddress,
+    constructorCalldata,
+    addressSalt,
+    maxFee,
+    version,
+    chainId,
+    nonce,
+  }: DeployAccountSignerDetails) {
+    const msgHash = calculateDeployAccountTransactionHash(
+      contractAddress,
+      classHash,
+      constructorCalldata,
+      addressSalt,
+      version,
+      maxFee,
+      chainId,
+      nonce
+    );
+
+    return sign(this.keyPair, msgHash);
+  }
+
   public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
     const msgHash = getMessageHash(typedData, accountAddress);
     return sign(this.keyPair, msgHash);

package/src/signer/interface.ts

@@ -1,4 +1,5 @@
-import { Abi, Call, InvocationsSignerDetails, Signature } from '../types';
+import { Abi, Call, DeclareSignerDetails, InvocationsSignerDetails, Signature } from '../types';
+import { DeployAccountSignerDetails } from '../types/signer';
 import { TypedData } from '../utils/typedData';
 
 export abstract class SignerInterface {
@@ -27,7 +28,6 @@ export abstract class SignerInterface {
    * - contractAddress - the address of the contract
    * - entrypoint - the entrypoint of the contract
    * - calldata - (defaults to []) the calldata
-   * - signature - (defaults to []) the signature
    * @param abi (optional) the abi of the contract for better displaying
    *
    * @returns signature
@@ -37,4 +37,33 @@ export abstract class SignerInterface {
     transactionsDetail: InvocationsSignerDetails,
     abis?: Abi[]
   ): Promise<Signature>;
+
+  /**
+   * Signs a DEPLOY_ACCOUNT transaction with the starknet private key and returns the signature
+   * @param transaction
+   * - contractAddress - the computed address of the contract
+   * - constructorCalldata - calldata to be passed in deploy constructor
+   * - addressSalt - contract address salt
+   * - chainId - the chainId to declare contract on
+   * - maxFee - maxFee for the declare transaction
+   * - version - transaction version
+   * - nonce - Nonce of the declare transaction
+   * @returns signature
+   */
+  public abstract signDeployAccountTransaction(
+    transaction: DeployAccountSignerDetails
+  ): Promise<Signature>;
+
+  /**
+   * Signs a DECLARE transaction with the starknet private key and returns the signature
+   * @param transaction
+   * - classHash - computed class hash. Will be replaced by ContractClass in future once class hash is present in CompiledContract
+   * - senderAddress - the address of the sender
+   * - chainId - the chainId to declare contract on
+   * - maxFee - maxFee for the declare transaction
+   * - version - transaction version
+   * - nonce - Nonce of the declare transaction
+   * @returns signature
+   */
+  public abstract signDeclareTransaction(transaction: DeclareSignerDetails): Promise<Signature>;
 }

package/src/types/api/openrpc.ts

@@ -18,7 +18,7 @@ type BLOCK_HASH = FELT;
 type TXN_HASH = FELT;
 type PROTOCOL_VERSION = string;
 type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
-type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'DEPLOY_ACCOUNT' | 'INVOKE' | 'L1_HANDLER';
 type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
 enum BLOCK_TAG {
   'latest',
@@ -104,6 +104,15 @@ type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
   class_hash: FELT;
   sender_address: ADDRESS;
 };
+type DEPLOY_ACCOUNT_TXN_REQUEST = COMMON_TXN_PROPERTIES & {
+  class_hash: FELT;
+  contract_address_salt: FELT;
+  constructor_calldata: Array<FELT>;
+};
+type DECLARE_TXN_REQUEST = COMMON_TXN_PROPERTIES & {
+  contract_class: CONTRACT_CLASS;
+  sender_address: ADDRESS;
+};
 type DEPLOY_TXN = {
   transaction_hash: TXN_HASH;
   class_hash: FELT;
@@ -328,7 +337,10 @@ export namespace OPENRPC {
         | Errors.INVALID_BLOCK_ID;
     };
     starknet_estimateFee: {
-      params: { request: INVOKE_TXN; block_id: BLOCK_ID };
+      params: {
+        request: INVOKE_TXN | DECLARE_TXN_REQUEST | DEPLOY_ACCOUNT_TXN_REQUEST;
+        block_id: BLOCK_ID;
+      };
       result: FEE_ESTIMATE;
       errors:
         | Errors.CONTRACT_NOT_FOUND
@@ -384,7 +396,11 @@ export namespace OPENRPC {
     starknet_addDeclareTransaction: {
       params: {
         contract_class: CONTRACT_CLASS;
+        sender_address: ADDRESS;
+        signature: SIGNATURE;
+        max_fee: NUM_AS_HEX;
         version: NUM_AS_HEX;
+        nonce: FELT;
       };
       result: DeclaredTransaction;
       errors: Errors.INVALID_CONTRACT_CLASS;
@@ -399,6 +415,16 @@ export namespace OPENRPC {
       errors: Errors.INVALID_CONTRACT_CLASS;
     };
 
+    starknet_addDeployAccountTransaction: {
+      params: {
+        contract_address_salt: FELT;
+        constructor_calldata: Array<FELT>;
+        class_hash: FELT;
+      };
+      result: DeployedTransaction;
+      errors: Errors.INVALID_CONTRACT_CLASS;
+    };
+
     // Trace API
     starknet_traceTransaction: {
       params: { transaction_hash: TXN_HASH };