starknet 4.8.0 → 4.10.0

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';
@@ -34,6 +38,7 @@ import { Block, BlockIdentifier } from './utils';
 export type RpcProviderOptions = {
   nodeUrl: string;
   retries?: number;
+  headers?: object;
 };
 
 export class RpcProvider implements ProviderInterface {
@@ -42,14 +47,17 @@ export class RpcProvider implements ProviderInterface {
   // from interface
   public chainId!: StarknetChainId;
 
+  public headers: object;
+
   private responseParser = new RPCResponseParser();
 
   private retries: number;
 
   constructor(optionsOrProvider: RpcProviderOptions) {
-    const { nodeUrl, retries } = optionsOrProvider;
+    const { nodeUrl, retries, headers } = optionsOrProvider;
     this.nodeUrl = nodeUrl;
     this.retries = retries || 200;
+    this.headers = { 'Content-Type': 'application/json', ...headers };
 
     this.getChainId().then((chainId) => {
       this.chainId = chainId;
@@ -60,7 +68,7 @@ export class RpcProvider implements ProviderInterface {
     return fetch(this.nodeUrl, {
       method: 'POST',
       body: stringify({ method, jsonrpc: '2.0', params, id: 0 }),
-      headers: { 'Content-Type': 'application/json' },
+      headers: this.headers,
     });
   }
 
@@ -183,9 +191,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> {
@@ -194,7 +200,7 @@ export class RpcProvider implements ProviderInterface {
 
   public async getClassAt(
     contractAddress: string,
-    blockIdentifier: BlockIdentifier
+    blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<RPC.ContractClass> {
     const block_id = new Block(blockIdentifier).identifier;
     return this.fetchEndpoint('starknet_getClassAt', {
@@ -214,33 +220,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 +328,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 +395,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,
@@ -24,6 +23,7 @@ import {
   GetTransactionTraceResponse,
   Sequencer,
 } from '../types/api';
+import { DeclareContractTransaction, DeployAccountContractTransaction } from '../types/lib';
 import fetch from '../utils/fetchPonyfill';
 import { getSelector, getSelectorFromName } from '../utils/hash';
 import { parse, parseAlwaysAsBig, stringify } from '../utils/json';
@@ -44,7 +44,7 @@ import { GatewayError, HttpError } from './errors';
 import { ProviderInterface } from './interface';
 import { Block, BlockIdentifier } from './utils';
 
-type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
+type NetworkName = 'mainnet-alpha' | 'goerli-alpha' | 'goerli-alpha-2';
 
 function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
   return (
@@ -62,6 +62,7 @@ export type SequencerProviderOptions =
       feederGatewayUrl?: string;
       gatewayUrl?: string;
       chainId?: StarknetChainId;
+      headers?: object;
     };
 
 export class SequencerProvider implements ProviderInterface {
@@ -73,9 +74,11 @@ export class SequencerProvider implements ProviderInterface {
 
   public chainId: StarknetChainId;
 
+  public headers: object | undefined;
+
   private responseParser = new SequencerAPIResponseParser();
 
-  constructor(optionsOrProvider: SequencerProviderOptions = { network: 'goerli-alpha' }) {
+  constructor(optionsOrProvider: SequencerProviderOptions = { network: 'goerli-alpha-2' }) {
     if ('network' in optionsOrProvider) {
       this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
       this.chainId = SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
@@ -93,6 +96,8 @@ export class SequencerProvider implements ProviderInterface {
       this.chainId =
         optionsOrProvider.chainId ??
         SequencerProvider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
+
+      this.headers = optionsOrProvider?.headers;
     }
   }
 
@@ -101,6 +106,9 @@ export class SequencerProvider implements ProviderInterface {
       case 'mainnet-alpha':
         return 'https://alpha-mainnet.starknet.io';
       case 'goerli-alpha':
+        return 'https://alpha4.starknet.io';
+      case 'goerli-alpha-2':
+        return 'https://alpha4-2.starknet.io';
       default:
         return 'https://alpha4.starknet.io';
     }
@@ -153,19 +161,20 @@ export class SequencerProvider implements ProviderInterface {
     return `?${queryString}`;
   }
 
-  private getHeaders(method: 'POST' | 'GET'): Record<string, string> | undefined {
+  private getHeaders(method: 'POST' | 'GET'): object | undefined {
     if (method === 'POST') {
       return {
         'Content-Type': 'application/json',
+        ...this.headers,
       };
     }
-    return undefined;
+    return this.headers;
   }
 
   // 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
@@ -321,17 +330,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);
   }
 
@@ -339,6 +365,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',
@@ -354,6 +388,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'

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';
@@ -16,6 +28,11 @@ export class Signer implements SignerInterface {
     return getStarkKey(this.keyPair);
   }
 
+  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
+    const msgHash = getMessageHash(typedData, accountAddress);
+    return sign(this.keyPair, msgHash);
+  }
+
   public async signTransaction(
     transactions: Call[],
     transactionsDetail: InvocationsSignerDetails,
@@ -40,8 +57,43 @@ export class Signer implements SignerInterface {
     return sign(this.keyPair, msgHash);
   }
 
-  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
-    const msgHash = getMessageHash(typedData, accountAddress);
+  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 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);
   }
 }

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,35 @@ 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/index.ts

@@ -1,10 +1,6 @@
 import { BigNumberish } from '../../utils/number';
 import { Signature } from '../lib';
 
-export type RawArgs = {
-  [inputName: string]: string | string[] | { type: 'struct'; [k: string]: BigNumberish };
-};
-
 export type Calldata = string[];
 
 export type Overrides = {

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 };

package/src/types/api/sequencer.ts

@@ -5,13 +5,13 @@ import { BigNumberish } from '../../utils/number';
 import {
   Abi,
   BlockNumber,
+  ContractClass,
   EntryPointType,
   RawCalldata,
   Signature,
   Status,
   TransactionStatus,
 } from '../lib';
-import { ContractClass } from '../provider';
 
 export type GetTransactionStatusResponse = {
   tx_status: Status;
@@ -76,10 +76,12 @@ export type CallL1Handler = {
 export namespace Sequencer {
   export type DeclareTransaction = {
     type: 'DECLARE';
+    sender_address: string;
     contract_class: ContractClass;
+    signature?: Signature;
     nonce: BigNumberish;
-    sender_address: BigNumberish;
-    signature: Signature;
+    max_fee?: BigNumberish;
+    version?: BigNumberish;
   };
 
   export type DeployTransaction = {
@@ -90,6 +92,17 @@ export namespace Sequencer {
     nonce?: BigNumberish;
   };
 
+  export type DeployAccountTransaction = {
+    type: 'DEPLOY_ACCOUNT';
+    class_hash: string;
+    contract_address_salt: BigNumberish;
+    constructor_calldata: string[];
+    signature?: Signature;
+    max_fee?: BigNumberish;
+    version?: BigNumberish;
+    nonce?: BigNumberish;
+  };
+
   export type InvokeFunctionTransaction = {
     type: 'INVOKE_FUNCTION';
     contract_address: string;
@@ -101,7 +114,11 @@ export namespace Sequencer {
     version?: BigNumberish;
   };
 
-  export type Transaction = DeclareTransaction | DeployTransaction | InvokeFunctionTransaction;
+  export type Transaction =
+    | DeclareTransaction
+    | DeployTransaction
+    | InvokeFunctionTransaction
+    | DeployAccountTransaction;
 
   export type AddTransactionResponse = {
     transaction_hash: string;
@@ -209,10 +226,16 @@ export namespace Sequencer {
     result: string[];
   };
 
-  export type EstimateFeeTransaction = Omit<
-    InvokeFunctionTransaction,
-    'max_fee' | 'entry_point_type'
-  >;
+  export type InvokeEstimateFee = Omit<InvokeFunctionTransaction, 'max_fee' | 'entry_point_type'>;
+  export type DeclareEstimateFee = Omit<DeclareTransaction, 'max_fee'>;
+  export type DeployAccountEstimateFee = Omit<DeployAccountTransaction, 'max_fee'>;
+  export type DeployEstimateFee = DeployTransaction;
+
+  export type EstimateFeeRequest =
+    | InvokeEstimateFee
+    | DeclareEstimateFee
+    | DeployEstimateFee
+    | DeployAccountEstimateFee;
 
   // Support 0.9.1 changes in a backward-compatible way
   export type EstimateFeeResponse =
@@ -308,7 +331,7 @@ export namespace Sequencer {
       QUERY: {
         blockIdentifier: BlockIdentifier;
       };
-      REQUEST: EstimateFeeTransaction;
+      REQUEST: EstimateFeeRequest;
       RESPONSE: EstimateFeeResponse;
     };
     get_class_by_hash: {