starknet 3.18.0 → 3.19.0

package/src/account/interface.ts

@@ -2,13 +2,13 @@ import { ProviderInterface } from '../provider';
 import { SignerInterface } from '../signer';
 import {
   Abi,
-  AddTransactionResponse,
   Call,
-  DeployContractPayload,
+  EstimateFeeDetails,
+  EstimateFeeResponse,
   InvocationsDetails,
+  InvokeFunctionResponse,
   Signature,
 } from '../types';
-import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData/types';
 
@@ -17,21 +17,6 @@ export abstract class AccountInterface extends ProviderInterface {
 
   public abstract signer: SignerInterface;
 
-  /**
-   * Deploys a given compiled contract (json) to starknet
-   *
-   * @param payload payload to be deployed containing:
-   * - compiled contract code
-   * - constructor calldata
-   * - address salt
-   * @param abi the abi of the contract
-   * @returns a confirmation of sending a transaction on the starknet contract
-   */
-  public abstract override deployContract(
-    payload: DeployContractPayload,
-    abi?: Abi
-  ): Promise<AddTransactionResponse>;
-
   /**
    * Estimate Fee for a method on starknet
    *
@@ -46,7 +31,7 @@ export abstract class AccountInterface extends ProviderInterface {
   public abstract estimateFee(
     calls: Call | Call[],
     estimateFeeDetails?: EstimateFeeDetails
-  ): Promise<EstimateFee>;
+  ): Promise<EstimateFeeResponse>;
 
   /**
    * Invoke execute function in account contract
@@ -64,7 +49,7 @@ export abstract class AccountInterface extends ProviderInterface {
     transactions: Call | Call[],
     abis?: Abi[],
     transactionsDetail?: InvocationsDetails
-  ): Promise<AddTransactionResponse>;
+  ): Promise<InvokeFunctionResponse>;
 
   /**
    * Sign an JSON object for off-chain usage with the starknet private key and return the signature

package/src/contract/contractFactory.ts

@@ -34,19 +34,16 @@ export class ContractFactory {
     constructorCalldata?: RawCalldata,
     addressSalt?: BigNumberish
   ): Promise<Contract> {
-    const { address, code, transaction_hash } = await this.providerOrAccount.deployContract({
+    const { contract_address, transaction_hash } = await this.providerOrAccount.deployContract({
       contract: this.compiledContract,
       constructorCalldata,
       addressSalt,
     });
-    assert(
-      code === 'TRANSACTION_RECEIVED' && Boolean(address),
-      'Deployment of the contract failed'
-    );
+    assert(Boolean(contract_address), 'Deployment of the contract failed');
 
     const contractInstance = new Contract(
       this.compiledContract.abi,
-      address!,
+      contract_address!,
       this.providerOrAccount
     );
     contractInstance.deployTransactionHash = transaction_hash;

package/src/contract/default.ts

@@ -7,13 +7,13 @@ import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
   AbiEntry,
-  AddTransactionResponse,
   Args,
   AsyncContractFunction,
   Calldata,
   ContractFunction,
   FunctionAbi,
   Invocation,
+  InvokeFunctionResponse,
   Overrides,
   ParsedStruct,
   Result,
@@ -544,7 +544,7 @@ export class Contract implements ContractInterface {
     method: string,
     args: Array<any> = [],
     options: Overrides = {}
-  ): Promise<AddTransactionResponse> {
+  ): Promise<InvokeFunctionResponse> {
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
     // validate method and args
@@ -578,6 +578,9 @@ export class Contract implements ContractInterface {
       });
     }
 
+    // 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 || [],
@@ -609,13 +612,12 @@ export class Contract implements ContractInterface {
           calldata,
           entrypoint: method,
         },
-        { blockIdentifier }
+        blockIdentifier
       )
       .then((x) => this.parseResponse(method, x.result));
   }
 
   public async estimate(method: string, args: Array<any> = []) {
-    //  TODO; remove error as soon as estimate fees are supported
     // ensure contract is connected
     assert(this.address !== null, 'contract isnt connected to an address');
 

package/src/contract/interface.ts

@@ -3,10 +3,10 @@ import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
 import {
   Abi,
-  AddTransactionResponse,
   AsyncContractFunction,
   ContractFunction,
   Invocation,
+  InvokeFunctionResponse,
   Overrides,
   Result,
 } from '../types';
@@ -78,7 +78,7 @@ export abstract class ContractInterface {
     method: string,
     args?: Array<any>,
     options?: Overrides
-  ): Promise<AddTransactionResponse>;
+  ): Promise<InvokeFunctionResponse>;
 
   /**
    * Calls a method on a contract

package/src/provider/default.ts

@@ -1,440 +1,109 @@
-import urljoin from 'url-join';
-
-import { ONE, StarknetChainId, ZERO } from '../constants';
+import { StarknetChainId } from '../constants';
 import {
-  Abi,
-  AddTransactionResponse,
+  BlockTag,
   Call,
   CallContractResponse,
-  CompiledContract,
+  ContractClass,
   DeclareContractPayload,
+  DeclareContractResponse,
   DeployContractPayload,
-  Endpoints,
+  DeployContractResponse,
+  EstimateFeeResponse,
   GetBlockResponse,
-  GetCodeResponse,
-  GetContractAddressesResponse,
+  GetTransactionReceiptResponse,
   GetTransactionResponse,
-  GetTransactionStatusResponse,
-  GetTransactionTraceResponse,
   Invocation,
-  TransactionReceiptResponse,
+  InvocationsDetails,
+  InvokeFunctionResponse,
 } from '../types';
-import { getSelectorFromName } from '../utils/hash';
-import { parse, parseAlwaysAsBig, stringify } from '../utils/json';
-import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
-import { compressProgram, randomAddress } from '../utils/stark';
-import { GatewayError, HttpError } from './errors';
+import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
-import { BlockIdentifier, getFormattedBlockIdentifier } from './utils';
-
-type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
+import { RpcProvider, RpcProviderOptions } from './rpc';
+import { SequencerProvider, SequencerProviderOptions } from './sequencer';
+import { BlockIdentifier } from './utils';
 
-type ProviderOptions = { network: NetworkName } | { baseUrl: string };
-
-function wait(delay: number) {
-  return new Promise((res) => {
-    setTimeout(res, delay);
-  });
-}
-
-function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
-  return (
-    obj === undefined ||
-    Object.keys(obj).length === 0 ||
-    (Object.keys(obj).length === 1 &&
-      Object.entries(obj).every(([k, v]) => k === 'blockIdentifier' && v === null))
-  );
+export interface ProviderOptions {
+  sequencer?: SequencerProviderOptions;
+  rpc?: RpcProviderOptions;
 }
 
 export class Provider implements ProviderInterface {
-  public baseUrl: string;
-
-  public feederGatewayUrl: string;
-
-  public gatewayUrl: string;
-
-  public chainId: StarknetChainId;
-
-  constructor(
-    optionsOrProvider: ProviderOptions | ProviderInterface = { network: 'goerli-alpha' }
-  ) {
-    if (optionsOrProvider instanceof ProviderInterface) {
-      this.baseUrl = optionsOrProvider.baseUrl;
-      this.feederGatewayUrl = optionsOrProvider.feederGatewayUrl;
-      this.gatewayUrl = optionsOrProvider.gatewayUrl;
-      this.chainId =
-        optionsOrProvider.chainId ?? Provider.getChainIdFromBaseUrl(optionsOrProvider.baseUrl);
+  private provider!: ProviderInterface;
+
+  constructor(providerOrOptions?: ProviderOptions | ProviderInterface) {
+    if (providerOrOptions && 'chainId' in providerOrOptions) {
+      this.provider = providerOrOptions;
+    } else if (providerOrOptions?.rpc) {
+      this.provider = new RpcProvider(providerOrOptions.rpc);
+    } else if (providerOrOptions?.sequencer) {
+      this.provider = new SequencerProvider(providerOrOptions.sequencer);
     } else {
-      const baseUrl =
-        'baseUrl' in optionsOrProvider
-          ? optionsOrProvider.baseUrl
-          : Provider.getNetworkFromName(optionsOrProvider.network);
-      this.baseUrl = baseUrl;
-      this.chainId = Provider.getChainIdFromBaseUrl(baseUrl);
-      this.feederGatewayUrl = urljoin(baseUrl, 'feeder_gateway');
-      this.gatewayUrl = urljoin(baseUrl, 'gateway');
-    }
-  }
-
-  protected static getNetworkFromName(name: NetworkName) {
-    switch (name) {
-      case 'mainnet-alpha':
-        return 'https://alpha-mainnet.starknet.io';
-      case 'goerli-alpha':
-      default:
-        return 'https://alpha4.starknet.io';
-    }
-  }
-
-  protected static getChainIdFromBaseUrl(baseUrl: string): StarknetChainId {
-    try {
-      const url = new URL(baseUrl);
-      if (url.host.includes('mainnet.starknet.io')) {
-        return StarknetChainId.MAINNET;
-      }
-    } catch {
-      // eslint-disable-next-line no-console
-      console.error(`Could not parse baseUrl: ${baseUrl}`);
-    }
-    return StarknetChainId.TESTNET;
-  }
-
-  private getFetchUrl(endpoint: keyof Endpoints) {
-    const gatewayUrlEndpoints = ['add_transaction'];
-
-    return gatewayUrlEndpoints.includes(endpoint) ? this.gatewayUrl : this.feederGatewayUrl;
-  }
-
-  private getFetchMethod(endpoint: keyof Endpoints) {
-    const postMethodEndpoints = ['add_transaction', 'call_contract', 'estimate_fee'];
-
-    return postMethodEndpoints.includes(endpoint) ? 'POST' : 'GET';
-  }
-
-  private getQueryString(query?: Record<string, any>): string {
-    if (isEmptyQueryObject(query)) {
-      return '';
-    }
-    const queryString = Object.entries(query)
-      .map(([key, value]) => {
-        if (key === 'blockIdentifier') {
-          return `${getFormattedBlockIdentifier(value)}`;
-        }
-        return `${key}=${value}`;
-      })
-      .join('&');
-
-    return `?${queryString}`;
-  }
-
-  private getHeaders(method: 'POST' | 'GET'): Record<string, string> | undefined {
-    if (method === 'POST') {
-      return {
-        'Content-Type': 'application/json',
-      };
-    }
-    return undefined;
-  }
-
-  // typesafe fetch
-  protected async fetchEndpoint<T extends keyof Endpoints>(
-    endpoint: T,
-    // typescript type magiuc to create a nice fitting function interface
-    ...[query, request]: Endpoints[T]['QUERY'] extends never
-      ? Endpoints[T]['REQUEST'] extends never
-        ? [] // when no query and no request is needed, we can omit the query and request parameters
-        : [undefined, Endpoints[T]['REQUEST']]
-      : Endpoints[T]['REQUEST'] extends never
-      ? [Endpoints[T]['QUERY']] // when no request is needed, we can omit the request parameter
-      : [Endpoints[T]['QUERY'], Endpoints[T]['REQUEST']] // when both query and request are needed, we cant omit anything
-  ): Promise<Endpoints[T]['RESPONSE']> {
-    const baseUrl = this.getFetchUrl(endpoint);
-    const method = this.getFetchMethod(endpoint);
-    const queryString = this.getQueryString(query);
-    const headers = this.getHeaders(method);
-    const url = urljoin(baseUrl, endpoint, queryString);
-
-    try {
-      const res = await fetch(url, {
-        method,
-        body: stringify(request),
-        headers,
-      });
-      const textResponse = await res.text();
-      if (!res.ok) {
-        // This will allow user to handle contract errors
-        let responseBody: any;
-        try {
-          responseBody = parse(textResponse);
-        } catch {
-          // if error parsing fails, return an http error
-          throw new HttpError(res.statusText, res.status);
-        }
-
-        const errorCode = responseBody.code || ((responseBody as any)?.status_code as string); // starknet-devnet uses status_code instead of code; They need to fix that
-        throw new GatewayError(responseBody.message, errorCode); // Caught locally, and re-thrown for the user
-      }
-
-      if (endpoint === 'estimate_fee') {
-        return parseAlwaysAsBig(textResponse, (_, v) => {
-          if (v && typeof v === 'bigint') {
-            return toBN(v.toString());
-          }
-          return v;
-        });
-      }
-      return parse(textResponse) as Endpoints[T]['RESPONSE'];
-    } catch (err) {
-      // rethrow custom errors
-      if (err instanceof GatewayError || err instanceof HttpError) {
-        throw err;
-      }
-      if (err instanceof Error) {
-        throw Error(`Could not ${method} from endpoint \`${url}\`: ${err.message}`);
-      }
-      throw err;
+      this.provider = new SequencerProvider();
     }
   }
 
-  /**
-   * Gets the smart contract address on the goerli testnet.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L13-L15)
-   * @returns starknet smart contract addresses
-   */
-  public async getContractAddresses(): Promise<GetContractAddressesResponse> {
-    return this.fetchEndpoint('get_contract_addresses');
+  public get chainId(): StarknetChainId {
+    return this.provider.chainId;
   }
 
-  /**
-   * Calls a function on the StarkNet contract.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L25-L39)
-   *
-   * @param invokeTransaction - transaction to be invoked
-   * @param blockHash
-   * @param blockNumber
-   * @returns the result of the function on the smart contract.
-   */
-  public async callContract(
-    { contractAddress, entrypoint, calldata = [] }: Call,
-    { blockIdentifier = 'pending' }: { blockIdentifier?: BlockIdentifier } = {}
-  ): Promise<CallContractResponse> {
-    return this.fetchEndpoint(
-      'call_contract',
-      { blockIdentifier },
-      {
-        signature: [],
-        contract_address: contractAddress,
-        entry_point_selector: getSelectorFromName(entrypoint),
-        calldata,
-      }
-    );
-  }
-
-  /**
-   * Gets the block information
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L41-L53)
-   *
-   * @param blockHash
-   * @param blockNumber
-   * @returns the block object { block_number, previous_block_number, state_root, status, timestamp, transaction_receipts, transactions }
-   */
-  public async getBlock(blockIdentifier: BlockIdentifier = null): Promise<GetBlockResponse> {
-    return this.fetchEndpoint('get_block', { blockIdentifier });
+  public async getBlock(blockIdentifier: BlockIdentifier = 'pending'): Promise<GetBlockResponse> {
+    return this.provider.getBlock(blockIdentifier);
   }
 
-  /**
-   * Gets the code of the deployed contract.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L55-L68)
-   *
-   * @param contractAddress
-   * @param blockHash
-   * @param blockNumber
-   * @returns Bytecode and ABI of compiled contract
-   */
-  public async getCode(
+  public async getClassAt(
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
-  ): Promise<GetCodeResponse> {
-    return this.fetchEndpoint('get_code', { blockIdentifier, contractAddress });
+  ): Promise<ContractClass> {
+    return this.provider.getClassAt(contractAddress, blockIdentifier);
+  }
+
+  public async getEstimateFee(
+    invocation: Invocation,
+    blockIdentifier: BlockIdentifier = 'pending',
+    invocationDetails: InvocationsDetails = {}
+  ): Promise<EstimateFeeResponse> {
+    return this.provider.getEstimateFee(invocation, blockIdentifier, invocationDetails);
   }
 
-  // TODO: add proper type
-  /**
-   * Gets the contract's storage variable at a specific key.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/fc97bdd8322a7df043c87c371634b26c15ed6cee/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L70-L85)
-   *
-   * @param contractAddress
-   * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-   * @param blockHash
-   * @param blockNumber
-   * @returns the value of the storage variable
-   */
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,
-    blockIdentifier: BlockIdentifier = 'pending'
-  ): Promise<object> {
-    return this.fetchEndpoint('get_storage_at', { blockIdentifier, contractAddress, key });
+    blockTagOrHash: BlockTag | BigNumberish = 'pending'
+  ): Promise<BigNumberish> {
+    return this.provider.getStorageAt(contractAddress, key, blockTagOrHash);
   }
 
-  /**
-   * Gets the status of a transaction.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L48-L52)
-   *
-   * @param txHash
-   * @returns the transaction status object { block_number, tx_status: NOT_RECEIVED | RECEIVED | PENDING | REJECTED | ACCEPTED_ONCHAIN }
-   */
-  public async getTransactionStatus(txHash: BigNumberish): Promise<GetTransactionStatusResponse> {
-    const txHashHex = toHex(toBN(txHash));
-    return this.fetchEndpoint('get_transaction_status', { transactionHash: txHashHex });
-  }
-
-  /**
-   * Gets the transaction receipt from a tx hash.
-   *
-   * [Reference] (https://github.com/starkware-libs/cairo-lang/blob/167b28bcd940fd25ea3816204fa882a0b0a49603/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L183)
-   *
-   * @param txHash
-   * @returns the transaction receipt object
-   */
-  public async getTransactionReceipt(txHash: BigNumberish): Promise<TransactionReceiptResponse> {
-    const txHashHex = toHex(toBN(txHash));
-    return this.fetchEndpoint('get_transaction_receipt', { transactionHash: txHashHex });
-  }
-
-  /**
-   * Gets the transaction information from a tx id.
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/feeder_gateway/feeder_gateway_client.py#L54-L58)
-   *
-   * @param txHash
-   * @returns the transacton object { transaction_id, status, transaction, block_number?, block_number?, transaction_index?, transaction_failure_reason? }
-   */
   public async getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse> {
-    const txHashHex = toHex(toBN(txHash));
-    return this.fetchEndpoint('get_transaction', { transactionHash: txHashHex });
+    return this.provider.getTransaction(txHash);
   }
 
-  /**
-   * Gets the transaction trace from a tx id.
-   *
-   *
-   * @param txHash
-   * @returns the transaction trace
-   */
-  public async getTransactionTrace(txHash: BigNumberish): Promise<GetTransactionTraceResponse> {
-    const txHashHex = toHex(toBN(txHash));
-    return this.fetchEndpoint('get_transaction_trace', { transactionHash: txHashHex });
+  public async getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse> {
+    return this.provider.getTransactionReceipt(txHash);
   }
 
-  /**
-   * Declare a given compiled contract (json) on starknet
-   *
-   * @param contract - a json object containing the compiled contract
-   * @returns a confirmation of sending a transaction on the starknet contract
-   */
-  public declareContract(payload: DeclareContractPayload): Promise<AddTransactionResponse> {
-    const parsedContract =
-      typeof payload.contract === 'string'
-        ? (parse(payload.contract) as CompiledContract)
-        : payload.contract;
-    const contractDefinition = {
-      ...parsedContract,
-      program: compressProgram(parsedContract.program),
-    };
-
-    return this.fetchEndpoint('add_transaction', undefined, {
-      type: 'DECLARE',
-      contract_class: contractDefinition,
-      nonce: toHex(ZERO),
-      signature: [],
-      sender_address: toHex(ONE),
-    });
+  public async callContract(
+    request: Call,
+    blockIdentifier: BlockIdentifier = 'pending'
+  ): Promise<CallContractResponse> {
+    return this.provider.callContract(request, blockIdentifier);
   }
 
-  /**
-   * Deploys a given compiled contract (json) to starknet
-   *
-   * @param contract - a json object containing the compiled contract
-   * @param address - (optional, defaults to a random address) the address where the contract should be deployed (alpha)
-   * @returns a confirmation of sending a transaction on the starknet contract
-   */
-  public deployContract(
-    payload: DeployContractPayload,
-    _abi?: Abi
-  ): Promise<AddTransactionResponse> {
-    const parsedContract =
-      typeof payload.contract === 'string'
-        ? (parse(payload.contract) as CompiledContract)
-        : payload.contract;
-    const contractDefinition = {
-      ...parsedContract,
-      program: compressProgram(parsedContract.program),
-    };
-
-    return this.fetchEndpoint('add_transaction', undefined, {
-      type: 'DEPLOY',
-      contract_address_salt: payload.addressSalt ?? randomAddress(),
-      constructor_calldata: bigNumberishArrayToDecimalStringArray(
-        payload.constructorCalldata ?? []
-      ),
-      contract_definition: contractDefinition,
-    });
+  public async invokeFunction(
+    functionInvocation: Invocation,
+    details: InvocationsDetails
+  ): Promise<InvokeFunctionResponse> {
+    return this.provider.invokeFunction(functionInvocation, details);
   }
 
-  /**
-   * Invokes a function on starknet
-   * @deprecated This method wont be supported as soon as fees are mandatory
-   *
-   * @param invocation
-   * @param _abi - (optional) signature to send along
-   * @returns response from addTransaction
-   */
-  public invokeFunction(invocation: Invocation, _abi?: Abi): Promise<AddTransactionResponse> {
-    return this.fetchEndpoint('add_transaction', undefined, {
-      type: 'INVOKE_FUNCTION',
-      contract_address: invocation.contractAddress,
-      entry_point_selector: getSelectorFromName(invocation.entrypoint),
-      calldata: bigNumberishArrayToDecimalStringArray(invocation.calldata ?? []),
-      signature: bigNumberishArrayToDecimalStringArray(invocation.signature ?? []),
-    });
+  public async deployContract(payload: DeployContractPayload): Promise<DeployContractResponse> {
+    return this.provider.deployContract(payload);
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
-    let onchain = false;
-
-    while (!onchain) {
-      // eslint-disable-next-line no-await-in-loop
-      await wait(retryInterval);
-      // eslint-disable-next-line no-await-in-loop
-      const res = await this.getTransactionStatus(txHash);
-
-      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
-      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
-
-      if (successStates.includes(res.tx_status)) {
-        onchain = true;
-      } else if (errorStates.includes(res.tx_status)) {
-        const message = res.tx_failure_reason
-          ? `${res.tx_status}: ${res.tx_failure_reason.code}\n${res.tx_failure_reason.error_message}`
-          : res.tx_status;
-        const error = new Error(message) as Error & { response: GetTransactionStatusResponse };
-        error.response = res;
-        throw error;
-      }
-    }
+  public async declareContract(payload: DeclareContractPayload): Promise<DeclareContractResponse> {
+    return this.provider.declareContract(payload);
   }
 
-  /**
-   * @deprecated use `waitForTransaction` instead
-   */
-  public async waitForTx(txHash: BigNumberish, retryInterval: number = 8000) {
-    return this.waitForTransaction(txHash, retryInterval);
+  public async waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void> {
+    return this.provider.waitForTransaction(txHash, retryInterval);
   }
 }

package/src/provider/index.ts

@@ -2,6 +2,8 @@ import { Provider } from './default';
 
 export * from './default';
 export * from './errors';
+export * from './sequencer';
 export * from './interface';
+export * from './rpc';
 
 export const defaultProvider = new Provider();