@0xsequence/indexer 3.0.0-beta.8 → 3.0.0

package/src/indexer.gen.ts

@@ -1,79 +1,393 @@
 /* eslint-disable */
-// sequence-indexer v0.4.0 546b527de7002f409ffa602ad35b5a3abe979088
+// sequence-indexer v0.4.0 2bca559c4c590bce7d70c33df115a58399efec82
 // --
-// Code generated by webrpc-gen@v0.21.1 with typescript generator. DO NOT EDIT.
+// Code generated by Webrpc-gen@v0.31.2 with typescript generator. DO NOT EDIT.
 //
-// webrpc-gen -schema=indexer.ridl -service=Indexer -target=typescript -client -out=./clients/indexer.gen.ts
+// webrpc-gen -schema=merged.gen.json -service=Indexer -target=typescript -client -out=./clients/indexer.gen.ts
 
-export const WebrpcHeader = 'Webrpc'
-
-export const WebrpcHeaderValue = 'webrpc@v0.21.1;gen-typescript@v0.15.1;sequence-indexer@v0.4.0'
-
-// WebRPC description and code-gen version
-export const WebRPCVersion = 'v1'
+// Webrpc description and code-gen version
+export const WebrpcVersion = 'v1'
 
 // Schema version of your RIDL schema
-export const WebRPCSchemaVersion = 'v0.4.0'
+export const WebrpcSchemaVersion = 'v0.4.0'
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = '546b527de7002f409ffa602ad35b5a3abe979088'
+export const WebrpcSchemaHash = '2bca559c4c590bce7d70c33df115a58399efec82'
 
-type WebrpcGenVersions = {
-  webrpcGenVersion: string
-  codeGenName: string
-  codeGenVersion: string
-  schemaName: string
-  schemaVersion: string
-}
+//
+// Client interface
+//
 
-export function VersionFromHeader(headers: Headers): WebrpcGenVersions {
-  const headerValue = headers.get(WebrpcHeader)
-  if (!headerValue) {
-    return {
-      webrpcGenVersion: '',
-      codeGenName: '',
-      codeGenVersion: '',
-      schemaName: '',
-      schemaVersion: '',
-    }
-  }
+export interface IndexerClient {
+  addWebhookListener(req: AddWebhookListenerRequest, headers?: object, signal?: AbortSignal): Promise<AddWebhookListenerResponse>
 
-  return parseWebrpcGenVersions(headerValue)
-}
+  /**
+   * Fetches a single receipt and then will stop the subscription
+   */
+  fetchTransactionReceipt(
+    req: FetchTransactionReceiptRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<FetchTransactionReceiptResponse>
 
-function parseWebrpcGenVersions(header: string): WebrpcGenVersions {
-  const versions = header.split(';')
-  if (versions.length < 3) {
-    return {
-      webrpcGenVersion: '',
-      codeGenName: '',
-      codeGenVersion: '',
-      schemaName: '',
-      schemaVersion: '',
-    }
-  }
+  /**
+   * Fetches a single receipt with filter and then will stop the subscription
+   */
+  fetchTransactionReceiptWithFilter(
+    req: FetchTransactionReceiptWithFilterRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<FetchTransactionReceiptWithFilterResponse>
 
-  const [_, webrpcGenVersion] = versions[0]!.split('@')
-  const [codeGenName, codeGenVersion] = versions[1]!.split('@')
-  const [schemaName, schemaVersion] = versions[2]!.split('@')
+  /**
+   * Webhooks
+   */
+  getAllWebhookListeners(
+    req: GetAllWebhookListenersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetAllWebhookListenersResponse>
+
+  /**
+   * Get balance update aggregate values -- useful for syncing balance details of a contract, ie. from Skyweaver.
+   * Also consider using SubscribeBalanceUpdates or SubscribeEvents as other alternatives.
+   */
+  getBalanceUpdates(req: GetBalanceUpdatesRequest, headers?: object, signal?: AbortSignal): Promise<GetBalanceUpdatesResponse>
+
+  /**
+   * Get the chain ID of the indexer
+   */
+  getChainID(headers?: object, signal?: AbortSignal): Promise<GetChainIDResponse>
+
+  /**
+   * Queries an ethereum node for the latest and confirm ETH balances
+   * DEPRECATED: use GetNativeTokenBalance instead
+   *
+   * @deprecated GetNativeTokenBalance
+   */
+  getEtherBalance(req: GetEtherBalanceRequest, headers?: object, signal?: AbortSignal): Promise<GetEtherBalanceResponse>
+
+  /**
+   * GetMarketplaceOrders queries marketplace orders with filtering and pagination.
+   *
+   * Retrieves buy orders (offers) and sell orders (listings) from a specific marketplace
+   * and collection with comprehensive filtering options.
+   *
+   * Parameters:
+   * marketplaceContractAddress: Target marketplace contract (required)
+   * collectionAddress: NFT collection contract (required)
+   * filter: MarketplaceOrderFilter with options:
+   * - isListing: true=listings, false=offers, omit=both
+   * - userAddresses: Include specific users
+   * - currencyAddresses: Filter by currencies (empty=all)
+   * - orderIds: Filter by specific order ids (empty=all)
+   * - tokenIds: Filter by specific tokens (empty=all)
+   * - excludeUserAddresses: Exclude specific users
+   * - blockNumberGt: Orders greater than block number
+   * - createdAtAfter: Orders after timestamp
+   * - orderStatuses: Filter by status (OPEN, CLOSED, CANCELLED)
+   * - returnExpired: Include expired orders
+   * page: Pagination control (optional)
+   *
+   * Returns: Updated pagination info and array of matching orders
+   */
+  getMarketplaceOrders(
+    req: GetMarketplaceOrdersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetMarketplaceOrdersResponse>
+
+  /**
+   * GetMarketplaceTopOrders finds the most competitive orders for specific tokens.
+   *
+   * Optimized for price discovery, returns the best available orders for each token.
+   * Useful for displaying current market prices and finding trading opportunities.
+   *
+   * Parameters:
+   * marketplaceContractAddress: Target marketplace contract (required)
+   * collectionAddress: NFT collection contract (required)
+   * filter: MarketplaceTopOrdersFilter with options:
+   * - currencyAddresses: Consider specific currencies (empty=all)
+   * - tokenIds: Target token IDs (required, non-empty)
+   * - isListing: true=listings/sell orders, false=offers/buy orders
+   * - priceSort: ASC=lowest first, DESC=highest first
+   * - excludeUser: Hide orders from specific user
+   *
+   * Returns: Array of top-priced active orders, sorted by priceSort preference
+   */
+  getMarketplaceTopOrders(
+    req: GetMarketplaceTopOrdersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetMarketplaceTopOrdersResponse>
+
+  /**
+   * GetNativeTokenBalance queries an ethereum node for the latest native token account balance.
+   * The native token is the token of the chain the indexer is connected to, for example, ETH on Ethereum
+   * and POL on Polygon.
+   */
+  getNativeTokenBalance(
+    req: GetNativeTokenBalanceRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetNativeTokenBalanceResponse>
+
+  /**
+   * GetTokenBalances returns a balance summary/details for a specific account. By default
+   * if accountAddress is left empty, it will use the account from the jwt session.
+   *
+   * Also, if contractAddress is undefined, then it will list all current user coins/collectibles.
+   * But, if contractAddress is provided, then it will return the token balances for the contract, this is
+   * only useful for 1155, but for other tokens, it can act as a filter for the single balance.
+   *
+   * DEPRECATED: use GetTokenBalancesSummary / GetTokenBalancesDetails
+   *
+   * @deprecated GetTokenBalancesSummary
+   */
+  getTokenBalances(req: GetTokenBalancesRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenBalancesResponse>
+
+  /**
+   * GetTokenBalancesByContract returns a balances for a specific accounts and
+   * contracts. The collection ERC721 & ERC1155 tokens are represented as
+   * individual balances.
+   *
+   * If `filter` is not provided, it will error out as it requires at least
+   * contract address.
+   *
+   * If `filter.contractStatus` is not provided, it will include verified only
+   * tokens.
+   */
+  getTokenBalancesByContract(
+    req: GetTokenBalancesByContractRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesByContractResponse>
+
+  /**
+   * GetTokenBalancesDetails returns a detailed balance summary for a specific
+   * accounts. The collection ERC721 & ERC1155 tokens are represented as
+   * individual balances.
+   *
+   * If `filter` is not provided, it will use the filter with account from the
+   * jwt session.
+   *
+   * If `filter.contractStatus` is not provided, it will include verified only
+   * tokens.
+   */
+  getTokenBalancesDetails(
+    req: GetTokenBalancesDetailsRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesDetailsResponse>
+
+  /**
+   * GetTokenBalancesSummary returns a summary of token balances for a specific
+   * accounts. The collection ERC721 & ERC1155 tokens are represented as a
+   * single aggregated balance.
+   *
+   * If `filter` is not provided, it will use the filter with account from the
+   * jwt session.
+   *
+   * If `filter.contractStatus` is not provided, it will include verified only
+   * tokens.
+   */
+  getTokenBalancesSummary(
+    req: GetTokenBalancesSummaryRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesSummaryResponse>
+
+  /**
+   * GetTokenIDRanges returns the range of tokenIDs for a token collection contract.
+   * This is useful for ERC-721 and ERC-1155 contracts to get the range of valid tokenIDs. It is similar to
+   * GetTokenIDs, but returns the range of tokenIDs instead of the list of tokenIDs, which is more efficient
+   * for large collections and very easy to the caller to expand the range into a list of tokenIDs.
+   *
+   * NOTE: this method will only return up to 15,000 ranges, if there are more ranges, it will return
+   * a boolean to indicate there are more ranges beyond the first 15,000. Therefore, if `moreRanges` is
+   * false then you have all the ranges, but if true, you need to make a follow up call to fetch the next
+   * page of ranges.
+   *
+   * As an example, if a NFT collection of 100,000 tokens uses ids from 1,2,3,...,100_000 then this endpoint
+   * will return just a single range from [1,100_000], but if there are gaps between the sequence, then
+   * those will be broken into separate range entries.
+   */
+  getTokenIDRanges(req: GetTokenIDRangesRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenIDRangesResponse>
+
+  /**
+   * GetTokenIDs returns the list of each individual token id for a token collection contract.
+   * This is useful for ERC-721 and ERC-1155 contracts to get the list of valid tokenIDs.
+   */
+  getTokenIDs(req: GetTokenIDsRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenIDsResponse>
+
+  getTokenPrice(req: GetTokenPriceRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenPriceResponse>
+
+  getTokenPrices(req: GetTokenPricesRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenPricesResponse>
+
+  /**
+   * GetTokenSupplies returns the set of tokenIDs used by a contract address, supporting ERC-20, ERC-721, and ERC-1155
+   * contracts, and their respective supply as well.
+   */
+  getTokenSupplies(req: GetTokenSuppliesRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenSuppliesResponse>
+
+  /**
+   * GetTokenSuppliesMap returns the token supplies of ERC-20 and ERC-1155 tokens as requested in the `tokenMap`
+   * represented as a map of contractAddress :: []tokenIDs.
+   *
+   * For an ERC-20 specify tokenIDs as an empty array or [0], for example, { '0xdef': [] } or { '0xdef': [0] }
+   * For ERC-1155 pass the array of tokens are strings, ie. { '0xabc': ['1', '2', '3'] }
+   */
+  getTokenSuppliesMap(
+    req: GetTokenSuppliesMapRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenSuppliesMapResponse>
 
-  return {
-    webrpcGenVersion: webrpcGenVersion!,
-    codeGenName: codeGenName!,
-    codeGenVersion: codeGenVersion!,
-    schemaName: schemaName!,
-    schemaVersion: schemaVersion!,
-  }
+  /**
+   * History of mined transactions for the account which includes a list of token transfers (sent/recieved)
+   * and sent transactions from a Sequence wallet
+   */
+  getTransactionHistory(
+    req: GetTransactionHistoryRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTransactionHistoryResponse>
+
+  getWebhookListener(req: GetWebhookListenerRequest, headers?: object, signal?: AbortSignal): Promise<GetWebhookListenerResponse>
+
+  listTokenPrices(req: ListTokenPricesRequest, headers?: object, signal?: AbortSignal): Promise<ListTokenPricesResponse>
+
+  pauseAllWebhookListeners(
+    req: PauseAllWebhookListenersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<PauseAllWebhookListenersResponse>
+
+  /**
+   * Ping the indexer
+   */
+  ping(headers?: object, signal?: AbortSignal): Promise<PingResponse>
+
+  removeAllWebhookListeners(
+    req: RemoveAllWebhookListenersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<RemoveAllWebhookListenersResponse>
+
+  removeWebhookListener(
+    req: RemoveWebhookListenerRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<RemoveWebhookListenerResponse>
+
+  resumeAllWebhookListeners(
+    req: ResumeAllWebhookListenersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ResumeAllWebhookListenersResponse>
+
+  /**
+   * Get the current runtime health status of the indexer
+   */
+  runtimeStatus(headers?: object, signal?: AbortSignal): Promise<RuntimeStatusResponse>
+
+  /**
+   * SubscribeBalanceUpdates listens to balance updates for a specific contract address
+   */
+  subscribeBalanceUpdates(
+    req: SubscribeBalanceUpdatesRequest,
+    options: WebrpcStreamOptions<SubscribeBalanceUpdatesResponse>
+  ): WebrpcStreamController
+
+  /**
+   * SubscribeEvents listens to events on-chain based on the filter criteria
+   *
+   * TODO: some additional options can be passed such as block, reorg true, etc.
+   * or stay behind, etc.
+   */
+  subscribeEvents(req: SubscribeEventsRequest, options: WebrpcStreamOptions<SubscribeEventsResponse>): WebrpcStreamController
+
+  /**
+   * Listen to transaction receipts on-chain based on the filter criteria
+   */
+  subscribeReceipts(
+    req: SubscribeReceiptsRequest,
+    options: WebrpcStreamOptions<SubscribeReceiptsResponse>
+  ): WebrpcStreamController
+
+  /**
+   * Re-sync an incorrect token balance with the correct on-chain balance
+   * NOTE: this method is almost never used, but we've marked it internal in case
+   * we ever want to use it again. This method was written a very long time ago in
+   * scenarios when the indexer had little bugs, but now its solid.
+   */
+  syncBalance(req: SyncBalanceRequest, headers?: object, signal?: AbortSignal): Promise<SyncBalanceResponse>
+
+  toggleWebhookListener(
+    req: ToggleWebhookListenerRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ToggleWebhookListenerResponse>
+
+  updateWebhookListener(
+    req: UpdateWebhookListenerRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateWebhookListenerResponse>
+
+  /**
+   * Get the current version of the indexer
+   */
+  version(headers?: object, signal?: AbortSignal): Promise<VersionResponse>
 }
 
 //
-// Types
+// Schema types
 //
 
-export enum ResourceStatus {
-  NOT_AVAILABLE = 'NOT_AVAILABLE',
-  REFRESHING = 'REFRESHING',
-  AVAILABLE = 'AVAILABLE',
+export interface Asset {
+  id: number
+  collectionId: number
+  tokenId?: string
+  url?: string
+  metadataField: string
+  name?: string
+  filesize?: number
+  mimeType?: string
+  width?: number
+  height?: number
+  updatedAt?: string
+}
+
+export enum BackupMode {
+  INCREMENTAL = 'INCREMENTAL',
+  COMPLETE = 'COMPLETE'
+}
+
+export interface BloomStats {
+  hitRatio: string
+  falsePositivesPercent: string
+  hitCount: number
+  missCount: number
+  falsePositives: number
+}
+
+export interface BloomStatus {
+  enabled: boolean
+  initialized: boolean
+  bloomInitElapsedTime: string
+  stats: BloomStats
+}
+
+export interface Bond {
+  pebble: PebbleMetrics
+  estimatedDiskUsagePerTable: any
+  estimatedDiskUsageTotal: string
+}
+
+export interface ChainInfo {
+  chainId: number
+  chainName: string
 }
 
 export interface ContractInfo {
@@ -93,56 +407,29 @@ export interface ContractInfo {
   status: ResourceStatus
 }
 
-export interface ContractInfoExtensions {
-  link: string
-  description: string
-  categories: Array<string>
-  ogImage: string
-  ogName: string
-  originChainId: number
-  originAddress: string
-  blacklist: boolean
-  verified: boolean
-  verifiedBy: string
-  featured: boolean
-  featureIndex: number
+export interface ContractInfoExtensionBridgeInfo {
+  tokenAddress: string
 }
 
-export interface TokenMetadata {
-  contractAddress?: string
-  tokenId: string
-  source: string
-  name: string
-  description?: string
-  image?: string
-  video?: string
-  audio?: string
-  properties?: { [key: string]: any }
-  attributes: Array<{ [key: string]: any }>
-  image_data?: string
-  external_url?: string
-  background_color?: string
-  animation_url?: string
-  decimals?: number
-  updatedAt?: string
-  assets?: Array<Asset>
-  status: ResourceStatus
-  queuedAt?: string
-  lastFetched?: string
+export interface ContractInfoExtensionIndexingInfo {
+  useOnChainBalance: boolean
 }
 
-export interface Asset {
-  id: number
-  collectionId: number
-  tokenId?: string
-  url?: string
-  metadataField: string
-  name?: string
-  filesize?: number
-  mimeType?: string
-  width?: number
-  height?: number
-  updatedAt?: string
+export interface ContractInfoExtensions {
+  link?: string
+  description?: string
+  categories?: Array<string>
+  bridgeInfo?: { [key: string]: ContractInfoExtensionBridgeInfo }
+  indexingInfo?: ContractInfoExtensionIndexingInfo
+  ogImage?: string
+  ogName?: string
+  originChainId?: number
+  originAddress?: string
+  blacklist?: boolean
+  verified?: boolean
+  verifiedBy?: string
+  featured?: boolean
+  featureIndex?: number
 }
 
 export enum ContractType {
@@ -156,72 +443,73 @@ export enum ContractType {
   ERC721_BRIDGE = 'ERC721_BRIDGE',
   ERC1155_BRIDGE = 'ERC1155_BRIDGE',
   SEQ_MARKETPLACE = 'SEQ_MARKETPLACE',
+  ERC6909 = 'ERC6909'
 }
 
-export enum EventLogType {
-  UNKNOWN = 'UNKNOWN',
-  BLOCK_ADDED = 'BLOCK_ADDED',
-  BLOCK_REMOVED = 'BLOCK_REMOVED',
-}
-
-export enum EventLogDataType {
-  EVENT = 'EVENT',
-  TOKEN_TRANSFER = 'TOKEN_TRANSFER',
-  NATIVE_TOKEN_TRANSFER = 'NATIVE_TOKEN_TRANSFER',
-  SEQUENCE_TXN = 'SEQUENCE_TXN',
-}
-
-export enum OrderStatus {
-  OPEN = 'OPEN',
-  CLOSED = 'CLOSED',
-  CANCELLED = 'CANCELLED',
+export enum ContractVerificationStatus {
+  VERIFIED = 'VERIFIED',
+  UNVERIFIED = 'UNVERIFIED',
+  ALL = 'ALL'
 }
 
-export enum TxnTransferType {
-  UNKNOWN = 'UNKNOWN',
-  SEND = 'SEND',
-  RECEIVE = 'RECEIVE',
+export interface DiskUsage {
+  humanReadable: string
+  used: number
+  size: number
+  percent: number
+  dirs: { [key: string]: string }
 }
 
-export enum TransactionStatus {
-  FAILED = 'FAILED',
-  SUCCESSFUL = 'SUCCESSFUL',
+export interface EtherBalance {
+  accountAddress: string
+  balanceWei: string
 }
 
-export enum TransactionType {
-  LegacyTxnType = 'LegacyTxnType',
-  AccessListTxnType = 'AccessListTxnType',
-  DynamicFeeTxnType = 'DynamicFeeTxnType',
+export interface EventDecoded {
+  topicHash: string
+  eventSig: string
+  types: Array<string>
+  names: Array<string>
+  values: Array<string>
 }
 
-export enum SortOrder {
-  DESC = 'DESC',
-  ASC = 'ASC',
+export interface EventFilter {
+  events?: Array<string>
+  contractAddresses?: Array<string>
+  accounts?: Array<string>
+  tokenIDs?: Array<string>
 }
 
-export enum ContractVerificationStatus {
-  VERIFIED = 'VERIFIED',
-  UNVERIFIED = 'UNVERIFIED',
-  ALL = 'ALL',
+export interface EventLog {
+  id: number
+  uid: string
+  type: EventLogType
+  blockNumber: number
+  blockHash: string
+  parentBlockHash: string
+  contractAddress: string
+  contractType: ContractType
+  txnHash: string
+  txnIndex: number
+  txnLogIndex: number
+  logDataType: EventLogDataType
+  ts: string
+  txnInfo?: TxnInfo
+  rawLog?: { [key: string]: any }
+  event?: EventDecoded
 }
 
-export interface Version {
-  webrpcVersion: string
-  schemaVersion: string
-  schemaHash: string
-  appVersion: string
+export enum EventLogDataType {
+  EVENT = 'EVENT',
+  TOKEN_TRANSFER = 'TOKEN_TRANSFER',
+  NATIVE_TOKEN_TRANSFER = 'NATIVE_TOKEN_TRANSFER',
+  SEQUENCE_TXN = 'SEQUENCE_TXN'
 }
 
-export interface RuntimeStatus {
-  healthOK: boolean
-  indexerEnabled: boolean
-  startTime: string
-  uptime: number
-  ver: string
-  branch: string
-  commitHash: string
-  chainID: number
-  checks: RuntimeChecks
+export enum EventLogType {
+  UNKNOWN = 'UNKNOWN',
+  BLOCK_ADDED = 'BLOCK_ADDED',
+  BLOCK_REMOVED = 'BLOCK_REMOVED'
 }
 
 export interface GatewayBackendResponseTime {
@@ -235,6 +523,30 @@ export interface GatewayBackendRuntimeStatus {
   responseTime: GatewayBackendResponseTime
 }
 
+export interface GatewayEtherBalance {
+  chainId: number
+  errorReason?: string
+  result: EtherBalance
+}
+
+export interface GatewayNativeTokenBalance {
+  chainId: number
+  errorReason?: string
+  result: NativeTokenBalance
+}
+
+export interface GatewayNativeTokenBalances {
+  chainId: number
+  errorReason?: string
+  results: Array<NativeTokenBalance>
+}
+
+export interface GatewayPrice {
+  chainID: number
+  errorReason?: string
+  results: Array<Price>
+}
+
 export interface GatewayRuntimeStatus {
   healthOK: boolean
   startTime: string
@@ -245,43 +557,115 @@ export interface GatewayRuntimeStatus {
   backends: Array<GatewayBackendRuntimeStatus>
 }
 
-export interface WALWriterRuntimeStatus {
-  healthOK: boolean
-  startTime: string
-  uptime: number
-  ver: string
-  branch: string
-  commitHash: string
+export interface GatewayTokenBalance {
+  chainId: number
+  errorReason?: string
+  results: Array<TokenBalance>
+}
+
+export interface GatewayTokenPriceQuery {
   chainID: number
-  percentWALWritten: number
+  queries: Array<TokenPriceQuery>
+}
+
+export interface GatewayTransaction {
+  chainId: number
+  errorReason?: string
+  results: Array<Transaction>
+}
+
+export interface IndexState {
+  chainId: string
+  lastBlockNum: number
+  lastBlockHash: string
+}
+
+export interface IndexedBlock {
+  blockNumber: number
+  blockShortHash: string
+}
+
+export interface IndexerMetrics {
+  blocksPerSecond: number
+  eventsPerSecond: number
+}
+
+export interface MarketplaceOrder {
+  orderId: string
+  tokenContract: string
+  tokenId: string
+  isListing: boolean
+  quantity: string
+  quantityRemaining: string
+  currencyAddress: string
+  pricePerToken: string
+  expiry: string
+  orderStatus: OrderStatus
+  createdBy: string
+  blockNumber: number
+  orderbookContractAddress: string
+  createdAt: number
+}
+
+export interface MarketplaceOrderFilter {
+  isListing?: boolean
+  userAddresses?: Array<string>
+  currencyAddresses: Array<string>
+  orderIds: Array<string>
+  tokenIds: Array<string>
+  excludeUserAddresses?: Array<string>
+  blockNumberGt: number
+  createdAtAfter: number
+  orderStatuses: Array<OrderStatus>
+  returnExpired: boolean
+}
+
+export interface MarketplaceTopOrdersFilter {
+  currencyAddresses: Array<string>
+  tokenIds: Array<string>
+  isListing: boolean
+  priceSort: SortOrder
+  excludeUser?: string
 }
 
-export interface RuntimeChecks {
-  running: boolean
-  runnables: any
-  cgoEnabled: boolean
-  quotaControlEnabled: boolean
-  syncMode: string
-  percentIndexed: number
-  lastBlockNum: number
-  lastBlockNumWithState: number
-  bloomStatus: BloomStatus
-  bond: Bond
-  diskUsage: DiskUsage
+export interface MetadataOptions {
+  verifiedOnly?: boolean
+  unverifiedOnly?: boolean
+  includeContracts?: Array<string>
 }
 
-export interface DiskUsage {
-  humanReadable: string
-  used: number
-  size: number
-  percent: number
-  dirs: { [key: string]: string }
+export interface NativeTokenBalance {
+  accountAddress: string
+  chainId: number
+  name: string
+  symbol: string
+  balance: string
+  balanceUSD: string
+  priceUSD: string
+  priceUpdatedAt?: string
+  errorReason?: string
 }
 
-export interface Bond {
-  pebble: PebbleMetrics
-  estimatedDiskUsagePerTable: any
-  estimatedDiskUsageTotal: string
+export enum NetworkType {
+  MAINNETS = 'MAINNETS',
+  TESTNETS = 'TESTNETS',
+  ALL = 'ALL'
+}
+
+export enum OrderStatus {
+  OPEN = 'OPEN',
+  CLOSED = 'CLOSED',
+  CANCELLED = 'CANCELLED'
+}
+
+export interface Page {
+  page?: number
+  column?: string
+  before?: any
+  after?: any
+  sort?: Array<SortBy>
+  pageSize?: number
+  more?: boolean
 }
 
 export interface PebbleMetrics {
@@ -292,66 +676,54 @@ export interface PebbleMetrics {
   compactionMarkedFiles: number
 }
 
-export interface BloomStatus {
-  enabled: boolean
-  initialized: boolean
-  bloomInitElapsedTime: string
-}
-
-export interface EtherBalance {
-  accountAddress: string
-  balanceWei: string
+export interface Price {
+  contractAddress: string
+  tokenID?: string
+  priceUSD: string
+  updatedAt?: string
 }
 
-export interface NativeTokenBalance {
-  accountAddress: string
-  chainId: number
-  balance: string
-  error: string
+export enum ResourceStatus {
+  NOT_AVAILABLE = 'NOT_AVAILABLE',
+  REFRESHING = 'REFRESHING',
+  AVAILABLE = 'AVAILABLE'
 }
 
-export interface IndexState {
-  chainId: string
+export interface RuntimeChecks {
+  running: boolean
+  runnables: any
+  cgoEnabled: boolean
+  quotaControlEnabled: boolean
+  syncMode: string
+  percentIndexed: number
   lastBlockNum: number
-  lastBlockHash: string
-}
-
-export interface IndexedBlock {
-  blockNumber: number
-  blockShortHash: string
+  lastBlockNumWithState: number
+  bloomStatus: BloomStatus
+  bond: Bond
+  diskUsage: DiskUsage
+  metrics: IndexerMetrics
 }
 
-export interface TxnInfo {
-  from: string
-  to: string
-  value: string
+export interface RuntimeStatus {
+  healthOK: boolean
+  indexerEnabled: boolean
+  startTime: string
+  uptime: number
+  ver: string
+  branch: string
+  commitHash: string
+  chainID: number
+  checks: RuntimeChecks
 }
 
-export interface EventLog {
-  id: number
-  uid: string
-  type: EventLogType
-  blockNumber: number
-  blockHash: string
-  parentBlockHash: string
-  contractAddress: string
-  contractType: ContractType
-  txnHash: string
-  txnIndex: number
-  txnLogIndex: number
-  logDataType: EventLogDataType
-  ts: string
-  txnInfo?: TxnInfo
-  rawLog?: { [key: string]: any }
-  event?: EventDecoded
+export interface SortBy {
+  column: string
+  order: SortOrder
 }
 
-export interface EventDecoded {
-  topicHash: string
-  eventSig: string
-  types: Array<string>
-  names: Array<string>
-  values: Array<string>
+export enum SortOrder {
+  DESC = 'DESC',
+  ASC = 'ASC'
 }
 
 export interface TokenBalance {
@@ -360,6 +732,9 @@ export interface TokenBalance {
   accountAddress: string
   tokenID?: string
   balance: string
+  balanceUSD: string
+  priceUSD: string
+  priceUpdatedAt?: string
   blockHash: string
   blockNumber: number
   chainId: number
@@ -369,39 +744,32 @@ export interface TokenBalance {
   tokenMetadata?: TokenMetadata
 }
 
-export interface OrderbookOrder {
-  orderId: string
-  tokenContract: string
-  tokenId: string
-  isListing: boolean
-  quantity: string
-  quantityRemaining: string
-  currencyAddress: string
-  pricePerToken: string
-  expiry: string
-  orderStatus: OrderStatus
-  createdBy: string
-  blockNumber: number
-  orderbookContractAddress: string
-  createdAt: number
+export interface TokenBalanceFilter {
+  contractAddress: string
+  sinceBlockNumber: number
 }
 
-export interface OrderbookOrderFilter {
-  isListing?: boolean
-  userAddresses?: Array<string>
-  tokenIds: Array<string>
-  excludeUserAddresses?: Array<string>
-  afterBlockNumber: number
-  afterCreatedAt: number
-  beforeExpiry: number
-  userAddress?: string
-  excludeUserAddress?: string
+export interface TokenBalancesByContractFilter {
+  contractAddresses: Array<string>
+  accountAddresses?: Array<string>
+  contractStatus?: ContractVerificationStatus
+  tokenIDs?: Array<string>
+}
+
+export interface TokenBalancesFilter {
+  accountAddresses: Array<string>
+  contractStatus?: ContractVerificationStatus
+  contractTypes?: Array<string>
+  contractWhitelist?: Array<string>
+  contractBlacklist?: Array<string>
+  omitNativeBalances: boolean
+  omitPrices?: boolean
+  tokenIDs?: Array<string>
 }
 
 export interface TokenHistory {
   blockNumber: number
   blockHash: string
-  accountAddress: string
   contractAddress: string
   contractType: ContractType
   fromAddress: string
@@ -409,12 +777,45 @@ export interface TokenHistory {
   txnHash: string
   txnIndex: number
   txnLogIndex: number
-  logData: string
   tokenIDs: string
-  Amounts: string
+  amounts: string
   ts: string
 }
 
+export interface TokenIDRange {
+  start: string
+  end: string
+}
+
+export interface TokenMetadata {
+  chainId?: number
+  contractAddress?: string
+  tokenId: string
+  source: string
+  name: string
+  description?: string
+  image?: string
+  video?: string
+  audio?: string
+  properties?: { [key: string]: any }
+  attributes: Array<{ [key: string]: any }>
+  image_data?: string
+  external_url?: string
+  background_color?: string
+  animation_url?: string
+  decimals?: number
+  updatedAt?: string
+  assets?: Array<Asset>
+  status: ResourceStatus
+  queuedAt?: string
+  lastFetched?: string
+}
+
+export interface TokenPriceQuery {
+  contractAddress: string
+  tokenID?: string
+}
+
 export interface TokenSupply {
   tokenID: string
   supply: string
@@ -433,17 +834,12 @@ export interface Transaction {
   timestamp: string
 }
 
-export interface TxnTransfer {
-  transferType: TxnTransferType
-  contractAddress: string
-  contractType: ContractType
-  from: string
-  to: string
-  tokenIds?: Array<string>
-  amounts: Array<string>
-  logIndex: number
-  contractInfo?: ContractInfo
-  tokenMetadata?: { [key: string]: TokenMetadata }
+export interface TransactionFilter {
+  txnHash?: string
+  from?: string
+  to?: string
+  contractAddress?: string
+  event?: string
 }
 
 export interface TransactionHistoryFilter {
@@ -456,14 +852,14 @@ export interface TransactionHistoryFilter {
   fromBlock?: number
   toBlock?: number
   tokenID?: string
+  omitPrices?: boolean
 }
 
-export interface TransactionFilter {
-  txnHash?: string
-  from?: string
-  to?: string
-  contractAddress?: string
-  event?: string
+export interface TransactionLog {
+  contractAddress: string
+  topics: Array<string>
+  data: string
+  index: number
 }
 
 export interface TransactionReceipt {
@@ -482,31 +878,60 @@ export interface TransactionReceipt {
   reorged: boolean
 }
 
-export interface TransactionLog {
-  contractAddress: string
-  topics: Array<string>
-  data: string
-  index: number
+export enum TransactionStatus {
+  FAILED = 'FAILED',
+  SUCCESSFUL = 'SUCCESSFUL'
 }
 
-export interface TokenIDRange {
-  start: string
-  end: string
+export enum TransactionType {
+  LegacyTxnType = 'LegacyTxnType',
+  AccessListTxnType = 'AccessListTxnType',
+  DynamicFeeTxnType = 'DynamicFeeTxnType'
+}
+
+export interface TxnInfo {
+  from: string
+  to: string
+  value: string
+}
+
+export interface TxnTransfer {
+  transferType: TxnTransferType
+  contractAddress: string
+  contractType: ContractType
+  from: string
+  to: string
+  tokenIds?: Array<string>
+  amounts: Array<string>
+  logIndex: number
+  amountsUSD?: Array<string>
+  pricesUSD?: Array<string>
+  contractInfo?: ContractInfo
+  tokenMetadata?: { [key: string]: TokenMetadata }
 }
 
-export interface Page {
-  page?: number
-  column?: string
-  before?: any
-  after?: any
-  sort?: Array<SortBy>
-  pageSize?: number
-  more?: boolean
+export enum TxnTransferType {
+  UNKNOWN = 'UNKNOWN',
+  SEND = 'SEND',
+  RECEIVE = 'RECEIVE'
 }
 
-export interface SortBy {
-  column: string
-  order: SortOrder
+export interface Version {
+  webrpcVersion: string
+  schemaVersion: string
+  schemaHash: string
+  appVersion: string
+}
+
+export interface WALWriterRuntimeStatus {
+  healthOK: boolean
+  startTime: string
+  uptime: number
+  ver: string
+  branch: string
+  commitHash: string
+  chainID: number
+  percentWALWritten: number
 }
 
 export interface WebhookListener {
@@ -519,469 +944,345 @@ export interface WebhookListener {
   active: boolean
 }
 
-export interface EventFilter {
-  events?: Array<string>
-  contractAddresses?: Array<string>
-  accounts?: Array<string>
-  tokenIDs?: Array<string>
+export interface AddWebhookListenerRequest {
+  url: string
+  filters: EventFilter
+  projectId?: number
 }
 
-export interface TokenBalanceFilter {
-  contractAddress: string
-  sinceBlockNumber: number
+export interface AddWebhookListenerResponse {
+  status: boolean
+  listener: WebhookListener
 }
 
-export interface MetadataOptions {
-  verifiedOnly?: boolean
-  unverifiedOnly?: boolean
-  includeContracts?: Array<string>
+export interface FetchTransactionReceiptRequest {
+  txnHash: string
+  maxBlockWait?: number
 }
 
-export interface TokenBalancesFilter {
-  accountAddresses: Array<string>
-  contractStatus?: ContractVerificationStatus
-  contractTypes?: Array<string>
-  contractWhitelist?: Array<string>
-  contractBlacklist?: Array<string>
-  omitNativeBalances: boolean
+export interface FetchTransactionReceiptResponse {
+  receipt: TransactionReceipt
 }
 
-export interface TokenBalancesByContractFilter {
-  contractAddresses: Array<string>
-  accountAddresses?: Array<string>
-  contractStatus?: ContractVerificationStatus
+export interface FetchTransactionReceiptWithFilterRequest {
+  filter: TransactionFilter
+  maxBlockWait?: number
 }
 
-export interface GatewayEtherBalance {
-  chainId: number
-  error: string
-  result: EtherBalance
+export interface FetchTransactionReceiptWithFilterResponse {
+  receipt: TransactionReceipt
 }
 
-export interface GatewayNativeTokenBalance {
-  chainId: number
-  error: string
-  result: NativeTokenBalance
+export interface GetAllWebhookListenersRequest {
+  projectId?: number
 }
 
-export interface GatewayNativeTokenBalances {
-  chainId: number
-  error: string
-  results: Array<NativeTokenBalance>
+export interface GetAllWebhookListenersResponse {
+  listeners: Array<WebhookListener>
 }
 
-export interface GatewayTokenBalance {
-  chainId: number
-  error: string
-  results: Array<TokenBalance>
+export interface GetBalanceUpdatesRequest {
+  contractAddress: string
+  lastBlockNumber: number
+  lastBlockHash?: string
+  page?: Page
 }
 
-export interface Indexer {
-  ping(headers?: object, signal?: AbortSignal): Promise<PingReturn>
-  version(headers?: object, signal?: AbortSignal): Promise<VersionReturn>
-  runtimeStatus(headers?: object, signal?: AbortSignal): Promise<RuntimeStatusReturn>
-  getChainID(headers?: object, signal?: AbortSignal): Promise<GetChainIDReturn>
-  getEtherBalance(args: GetEtherBalanceArgs, headers?: object, signal?: AbortSignal): Promise<GetEtherBalanceReturn>
-  getNativeTokenBalance(
-    args: GetNativeTokenBalanceArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetNativeTokenBalanceReturn>
-  getTokenBalancesSummary(
-    args: GetTokenBalancesSummaryArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesSummaryReturn>
-  getTokenBalancesDetails(
-    args: GetTokenBalancesDetailsArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesDetailsReturn>
-  getTokenBalancesByContract(
-    args: GetTokenBalancesByContractArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesByContractReturn>
-  getTokenBalances(args: GetTokenBalancesArgs, headers?: object, signal?: AbortSignal): Promise<GetTokenBalancesReturn>
-  getTokenSupplies(args: GetTokenSuppliesArgs, headers?: object, signal?: AbortSignal): Promise<GetTokenSuppliesReturn>
-  getTokenSuppliesMap(
-    args: GetTokenSuppliesMapArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenSuppliesMapReturn>
-  getTokenIDs(args: GetTokenIDsArgs, headers?: object, signal?: AbortSignal): Promise<GetTokenIDsReturn>
-  getTokenIDRanges(args: GetTokenIDRangesArgs, headers?: object, signal?: AbortSignal): Promise<GetTokenIDRangesReturn>
-  getBalanceUpdates(
-    args: GetBalanceUpdatesArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetBalanceUpdatesReturn>
-  getTransactionHistory(
-    args: GetTransactionHistoryArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTransactionHistoryReturn>
-  fetchTransactionReceipt(
-    args: FetchTransactionReceiptArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<FetchTransactionReceiptReturn>
-  fetchTransactionReceiptWithFilter(
-    args: FetchTransactionReceiptWithFilterArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<FetchTransactionReceiptWithFilterReturn>
-  subscribeReceipts(args: SubscribeReceiptsArgs, options: WebrpcStreamOptions<SubscribeReceiptsReturn>): Promise<void>
-  subscribeEvents(args: SubscribeEventsArgs, options: WebrpcStreamOptions<SubscribeEventsReturn>): Promise<void>
-  subscribeBalanceUpdates(
-    args: SubscribeBalanceUpdatesArgs,
-    options: WebrpcStreamOptions<SubscribeBalanceUpdatesReturn>,
-  ): Promise<void>
-  syncBalance(args: SyncBalanceArgs, headers?: object, signal?: AbortSignal): Promise<SyncBalanceReturn>
-  getAllWebhookListeners(
-    args: GetAllWebhookListenersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetAllWebhookListenersReturn>
-  getWebhookListener(
-    args: GetWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetWebhookListenerReturn>
-  addWebhookListener(
-    args: AddWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<AddWebhookListenerReturn>
-  updateWebhookListener(
-    args: UpdateWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<UpdateWebhookListenerReturn>
-  removeWebhookListener(
-    args: RemoveWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<RemoveWebhookListenerReturn>
-  removeAllWebhookListeners(
-    args: RemoveAllWebhookListenersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<RemoveAllWebhookListenersReturn>
-  toggleWebhookListener(
-    args: ToggleWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<ToggleWebhookListenerReturn>
-  pauseAllWebhookListeners(
-    args: PauseAllWebhookListenersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<PauseAllWebhookListenersReturn>
-  resumeAllWebhookListeners(
-    args: ResumeAllWebhookListenersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<ResumeAllWebhookListenersReturn>
-  getOrderbookOrders(
-    args: GetOrderbookOrdersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetOrderbookOrdersReturn>
-  getTopOrders(args: GetTopOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetTopOrdersReturn>
+export interface GetBalanceUpdatesResponse {
+  page: Page
+  balances: Array<TokenBalance>
 }
 
-export interface PingArgs {}
+export interface GetChainIDRequest {}
 
-export interface PingReturn {
-  status: boolean
+export interface GetChainIDResponse {
+  chainID: number
 }
-export interface VersionArgs {}
 
-export interface VersionReturn {
-  version: Version
+export interface GetEtherBalanceRequest {
+  accountAddress?: string
 }
-export interface RuntimeStatusArgs {}
 
-export interface RuntimeStatusReturn {
-  status: RuntimeStatus
+export interface GetEtherBalanceResponse {
+  balance: EtherBalance
 }
-export interface GetChainIDArgs {}
 
-export interface GetChainIDReturn {
-  chainID: number
+export interface GetMarketplaceOrdersRequest {
+  marketplaceContractAddress: string
+  collectionAddress: string
+  filter?: MarketplaceOrderFilter
+  page?: Page
 }
-export interface GetEtherBalanceArgs {
-  accountAddress?: string
+
+export interface GetMarketplaceOrdersResponse {
+  page?: Page
+  orders: Array<MarketplaceOrder>
 }
 
-export interface GetEtherBalanceReturn {
-  balance: EtherBalance
+export interface GetMarketplaceTopOrdersRequest {
+  marketplaceContractAddress: string
+  collectionAddress: string
+  filter: MarketplaceTopOrdersFilter
+}
+
+export interface GetMarketplaceTopOrdersResponse {
+  orders: Array<MarketplaceOrder>
 }
-export interface GetNativeTokenBalanceArgs {
+
+export interface GetNativeTokenBalanceRequest {
   accountAddress?: string
+  omitPrices?: boolean
 }
 
-export interface GetNativeTokenBalanceReturn {
+export interface GetNativeTokenBalanceResponse {
   balance: NativeTokenBalance
 }
-export interface GetTokenBalancesSummaryArgs {
-  filter: TokenBalancesFilter
-  omitMetadata?: boolean
+
+export interface GetTokenBalancesRequest {
+  accountAddress?: string
+  contractAddress?: string
+  tokenID?: string
+  includeMetadata?: boolean
+  metadataOptions?: MetadataOptions
+  includeCollectionTokens?: boolean
   page?: Page
 }
 
-export interface GetTokenBalancesSummaryReturn {
+export interface GetTokenBalancesResponse {
   page: Page
-  nativeBalances: Array<NativeTokenBalance>
   balances: Array<TokenBalance>
 }
-export interface GetTokenBalancesDetailsArgs {
-  filter: TokenBalancesFilter
+
+export interface GetTokenBalancesByContractRequest {
+  filter: TokenBalancesByContractFilter
   omitMetadata?: boolean
   page?: Page
 }
 
-export interface GetTokenBalancesDetailsReturn {
+export interface GetTokenBalancesByContractResponse {
   page: Page
-  nativeBalances: Array<NativeTokenBalance>
   balances: Array<TokenBalance>
 }
-export interface GetTokenBalancesByContractArgs {
-  filter: TokenBalancesByContractFilter
+
+export interface GetTokenBalancesDetailsRequest {
+  filter: TokenBalancesFilter
   omitMetadata?: boolean
   page?: Page
 }
 
-export interface GetTokenBalancesByContractReturn {
+export interface GetTokenBalancesDetailsResponse {
   page: Page
+  nativeBalances: Array<NativeTokenBalance>
   balances: Array<TokenBalance>
 }
-export interface GetTokenBalancesArgs {
-  accountAddress?: string
-  contractAddress?: string
-  tokenID?: string
-  includeMetadata?: boolean
-  metadataOptions?: MetadataOptions
-  includeCollectionTokens?: boolean
+
+export interface GetTokenBalancesSummaryRequest {
+  filter: TokenBalancesFilter
+  omitMetadata?: boolean
   page?: Page
 }
 
-export interface GetTokenBalancesReturn {
+export interface GetTokenBalancesSummaryResponse {
   page: Page
+  nativeBalances: Array<NativeTokenBalance>
   balances: Array<TokenBalance>
 }
-export interface GetTokenSuppliesArgs {
+
+export interface GetTokenIDRangesRequest {
   contractAddress: string
-  includeMetadata?: boolean
-  metadataOptions?: MetadataOptions
-  page?: Page
+  lastTokenID?: string
 }
 
-export interface GetTokenSuppliesReturn {
-  page: Page
+export interface GetTokenIDRangesResponse {
   contractType: ContractType
-  tokenIDs: Array<TokenSupply>
-}
-export interface GetTokenSuppliesMapArgs {
-  tokenMap: { [key: string]: Array<string> }
-  includeMetadata?: boolean
-  metadataOptions?: MetadataOptions
+  tokenIDRanges: Array<TokenIDRange>
+  moreRanges: boolean
 }
 
-export interface GetTokenSuppliesMapReturn {
-  supplies: { [key: string]: Array<TokenSupply> }
-}
-export interface GetTokenIDsArgs {
+export interface GetTokenIDsRequest {
   contractAddress: string
   page?: Page
 }
 
-export interface GetTokenIDsReturn {
+export interface GetTokenIDsResponse {
   page: Page
   contractType: ContractType
   tokenIDs: Array<string>
 }
-export interface GetTokenIDRangesArgs {
-  contractAddress: string
+
+export interface GetTokenPriceRequest {
+  q: TokenPriceQuery
 }
 
-export interface GetTokenIDRangesReturn {
-  contractType: ContractType
-  tokenIDRanges: Array<TokenIDRange>
-  moreRanges: boolean
+export interface GetTokenPriceResponse {
+  price: Price
+}
+
+export interface GetTokenPricesRequest {
+  q: Array<TokenPriceQuery>
+}
+
+export interface GetTokenPricesResponse {
+  prices: Array<Price>
 }
-export interface GetBalanceUpdatesArgs {
+
+export interface GetTokenSuppliesRequest {
   contractAddress: string
-  lastBlockNumber: number
-  lastBlockHash?: string
+  includeMetadata?: boolean
   page?: Page
 }
 
-export interface GetBalanceUpdatesReturn {
+export interface GetTokenSuppliesResponse {
   page: Page
-  balances: Array<TokenBalance>
+  contractType: ContractType
+  tokenIDs: Array<TokenSupply>
+}
+
+export interface GetTokenSuppliesMapRequest {
+  tokenMap: { [key: string]: Array<string> }
+  includeMetadata?: boolean
+}
+
+export interface GetTokenSuppliesMapResponse {
+  supplies: { [key: string]: Array<TokenSupply> }
 }
-export interface GetTransactionHistoryArgs {
+
+export interface GetTransactionHistoryRequest {
   filter: TransactionHistoryFilter
   page?: Page
   includeMetadata?: boolean
   metadataOptions?: MetadataOptions
 }
 
-export interface GetTransactionHistoryReturn {
+export interface GetTransactionHistoryResponse {
   page: Page
   transactions: Array<Transaction>
 }
-export interface FetchTransactionReceiptArgs {
-  txnHash: string
-  maxBlockWait?: number
-}
 
-export interface FetchTransactionReceiptReturn {
-  receipt: TransactionReceipt
-}
-export interface FetchTransactionReceiptWithFilterArgs {
-  filter: TransactionFilter
-  maxBlockWait?: number
+export interface GetWebhookListenerRequest {
+  id: number
+  projectId?: number
 }
 
-export interface FetchTransactionReceiptWithFilterReturn {
-  receipt: TransactionReceipt
-}
-export interface SubscribeReceiptsArgs {
-  filter: TransactionFilter
+export interface GetWebhookListenerResponse {
+  listener: WebhookListener
 }
 
-export interface SubscribeReceiptsReturn {
-  receipt: TransactionReceipt
-}
-export interface SubscribeEventsArgs {
-  filter: EventFilter
+export interface ListTokenPricesRequest {
+  page?: Page
 }
 
-export interface SubscribeEventsReturn {
-  log: EventLog
+export interface ListTokenPricesResponse {
+  page: Page
+  prices: Array<Price>
 }
-export interface SubscribeBalanceUpdatesArgs {
-  contractAddress: string
+
+export interface PauseAllWebhookListenersRequest {
+  projectId?: number
 }
 
-export interface SubscribeBalanceUpdatesReturn {
-  balance: TokenBalance
+export interface PauseAllWebhookListenersResponse {
+  status: boolean
 }
-export interface SyncBalanceArgs {
-  accountAddress: string
-  contractAddress: string
-  tokenID?: string
+
+export interface PingRequest {}
+
+export interface PingResponse {
+  status: boolean
 }
 
-export interface SyncBalanceReturn {}
-export interface GetAllWebhookListenersArgs {
+export interface RemoveAllWebhookListenersRequest {
   projectId?: number
 }
 
-export interface GetAllWebhookListenersReturn {
-  listeners: Array<WebhookListener>
+export interface RemoveAllWebhookListenersResponse {
+  status: boolean
 }
-export interface GetWebhookListenerArgs {
+
+export interface RemoveWebhookListenerRequest {
   id: number
   projectId?: number
 }
 
-export interface GetWebhookListenerReturn {
-  listener: WebhookListener
+export interface RemoveWebhookListenerResponse {
+  status: boolean
 }
-export interface AddWebhookListenerArgs {
-  url: string
-  filters: EventFilter
+
+export interface ResumeAllWebhookListenersRequest {
   projectId?: number
 }
 
-export interface AddWebhookListenerReturn {
+export interface ResumeAllWebhookListenersResponse {
   status: boolean
-  listener: WebhookListener
 }
-export interface UpdateWebhookListenerArgs {
-  listener: WebhookListener
-  projectId?: number
+
+export interface RuntimeStatusRequest {}
+
+export interface RuntimeStatusResponse {
+  status: RuntimeStatus
 }
 
-export interface UpdateWebhookListenerReturn {
-  status: boolean
+export interface SubscribeBalanceUpdatesRequest {
+  contractAddress: string
 }
-export interface RemoveWebhookListenerArgs {
-  id: number
-  projectId?: number
+
+export interface SubscribeBalanceUpdatesResponse {
+  balance: TokenBalance
+}
+
+export interface SubscribeEventsRequest {
+  filter: EventFilter
+}
+
+export interface SubscribeEventsResponse {
+  log: EventLog
 }
 
-export interface RemoveWebhookListenerReturn {
-  status: boolean
+export interface SubscribeReceiptsRequest {
+  filter: TransactionFilter
 }
-export interface RemoveAllWebhookListenersArgs {
-  projectId?: number
+
+export interface SubscribeReceiptsResponse {
+  receipt: TransactionReceipt
 }
 
-export interface RemoveAllWebhookListenersReturn {
-  status: boolean
+export interface SyncBalanceRequest {
+  accountAddress: string
+  contractAddress: string
+  tokenID?: string
 }
-export interface ToggleWebhookListenerArgs {
+
+export interface SyncBalanceResponse {}
+
+export interface ToggleWebhookListenerRequest {
   id: number
   projectId?: number
 }
 
-export interface ToggleWebhookListenerReturn {
+export interface ToggleWebhookListenerResponse {
   webhookListener: WebhookListener
 }
-export interface PauseAllWebhookListenersArgs {
-  projectId?: number
-}
 
-export interface PauseAllWebhookListenersReturn {
-  status: boolean
-}
-export interface ResumeAllWebhookListenersArgs {
+export interface UpdateWebhookListenerRequest {
+  listener: WebhookListener
   projectId?: number
 }
 
-export interface ResumeAllWebhookListenersReturn {
+export interface UpdateWebhookListenerResponse {
   status: boolean
 }
-export interface GetOrderbookOrdersArgs {
-  page?: Page
-  orderbookContractAddress: string
-  collectionAddress: string
-  currencyAddresses: Array<string>
-  filter: OrderbookOrderFilter
-  orderStatuses: Array<OrderStatus>
-  filters: Array<OrderbookOrderFilter>
-  beforeExpiryTimestamp: number
-  blockNumberAfter: number
-  createdAtAfter: number
-}
 
-export interface GetOrderbookOrdersReturn {
-  page?: Page
-  orders: Array<OrderbookOrder>
-}
-export interface GetTopOrdersArgs {
-  orderbookContractAddress: string
-  collectionAddress: string
-  currencyAddresses: Array<string>
-  tokenIDs: Array<string>
-  isListing: boolean
-  priceSort: SortOrder
-  excludeUser?: string
-}
+export interface VersionRequest {}
 
-export interface GetTopOrdersReturn {
-  orders: Array<OrderbookOrder>
+export interface VersionResponse {
+  version: Version
 }
 
 //
 // Client
 //
-export class Indexer implements Indexer {
+
+export class Indexer implements IndexerClient {
   protected hostname: string
   protected fetch: Fetch
   protected path = '/rpc/Indexer/'
@@ -995,601 +1296,652 @@ export class Indexer implements Indexer {
     return this.hostname + this.path + name
   }
 
-  ping = (headers?: object, signal?: AbortSignal): Promise<PingReturn> => {
-    return this.fetch(this.url('Ping'), createHTTPRequest({}, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+  queryKey = {
+    addWebhookListener: (req: AddWebhookListenerRequest) => ['Indexer', 'addWebhookListener', req] as const,
+    fetchTransactionReceipt: (req: FetchTransactionReceiptRequest) => ['Indexer', 'fetchTransactionReceipt', req] as const,
+    fetchTransactionReceiptWithFilter: (req: FetchTransactionReceiptWithFilterRequest) =>
+      ['Indexer', 'fetchTransactionReceiptWithFilter', req] as const,
+    getAllWebhookListeners: (req: GetAllWebhookListenersRequest) => ['Indexer', 'getAllWebhookListeners', req] as const,
+    getBalanceUpdates: (req: GetBalanceUpdatesRequest) => ['Indexer', 'getBalanceUpdates', req] as const,
+    getChainID: () => ['Indexer', 'getChainID'] as const,
+    getEtherBalance: (req: GetEtherBalanceRequest) => ['Indexer', 'getEtherBalance', req] as const,
+    getMarketplaceOrders: (req: GetMarketplaceOrdersRequest) => ['Indexer', 'getMarketplaceOrders', req] as const,
+    getMarketplaceTopOrders: (req: GetMarketplaceTopOrdersRequest) => ['Indexer', 'getMarketplaceTopOrders', req] as const,
+    getNativeTokenBalance: (req: GetNativeTokenBalanceRequest) => ['Indexer', 'getNativeTokenBalance', req] as const,
+    getTokenBalances: (req: GetTokenBalancesRequest) => ['Indexer', 'getTokenBalances', req] as const,
+    getTokenBalancesByContract: (req: GetTokenBalancesByContractRequest) =>
+      ['Indexer', 'getTokenBalancesByContract', req] as const,
+    getTokenBalancesDetails: (req: GetTokenBalancesDetailsRequest) => ['Indexer', 'getTokenBalancesDetails', req] as const,
+    getTokenBalancesSummary: (req: GetTokenBalancesSummaryRequest) => ['Indexer', 'getTokenBalancesSummary', req] as const,
+    getTokenIDRanges: (req: GetTokenIDRangesRequest) => ['Indexer', 'getTokenIDRanges', req] as const,
+    getTokenIDs: (req: GetTokenIDsRequest) => ['Indexer', 'getTokenIDs', req] as const,
+    getTokenPrice: (req: GetTokenPriceRequest) => ['Indexer', 'getTokenPrice', req] as const,
+    getTokenPrices: (req: GetTokenPricesRequest) => ['Indexer', 'getTokenPrices', req] as const,
+    getTokenSupplies: (req: GetTokenSuppliesRequest) => ['Indexer', 'getTokenSupplies', req] as const,
+    getTokenSuppliesMap: (req: GetTokenSuppliesMapRequest) => ['Indexer', 'getTokenSuppliesMap', req] as const,
+    getTransactionHistory: (req: GetTransactionHistoryRequest) => ['Indexer', 'getTransactionHistory', req] as const,
+    getWebhookListener: (req: GetWebhookListenerRequest) => ['Indexer', 'getWebhookListener', req] as const,
+    listTokenPrices: (req: ListTokenPricesRequest) => ['Indexer', 'listTokenPrices', req] as const,
+    pauseAllWebhookListeners: (req: PauseAllWebhookListenersRequest) => ['Indexer', 'pauseAllWebhookListeners', req] as const,
+    ping: () => ['Indexer', 'ping'] as const,
+    removeAllWebhookListeners: (req: RemoveAllWebhookListenersRequest) => ['Indexer', 'removeAllWebhookListeners', req] as const,
+    removeWebhookListener: (req: RemoveWebhookListenerRequest) => ['Indexer', 'removeWebhookListener', req] as const,
+    resumeAllWebhookListeners: (req: ResumeAllWebhookListenersRequest) => ['Indexer', 'resumeAllWebhookListeners', req] as const,
+    runtimeStatus: () => ['Indexer', 'runtimeStatus'] as const,
+    subscribeBalanceUpdates: (req: SubscribeBalanceUpdatesRequest) => ['Indexer', 'subscribeBalanceUpdates', req] as const,
+    subscribeEvents: (req: SubscribeEventsRequest) => ['Indexer', 'subscribeEvents', req] as const,
+    subscribeReceipts: (req: SubscribeReceiptsRequest) => ['Indexer', 'subscribeReceipts', req] as const,
+    syncBalance: (req: SyncBalanceRequest) => ['Indexer', 'syncBalance', req] as const,
+    toggleWebhookListener: (req: ToggleWebhookListenerRequest) => ['Indexer', 'toggleWebhookListener', req] as const,
+    updateWebhookListener: (req: UpdateWebhookListenerRequest) => ['Indexer', 'updateWebhookListener', req] as const,
+    version: () => ['Indexer', 'version'] as const
+  }
+
+  addWebhookListener = (
+    req: AddWebhookListenerRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<AddWebhookListenerResponse> => {
+    return this.fetch(this.url('AddWebhookListener'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<AddWebhookListenerResponse>(_data, 'AddWebhookListenerResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  version = (headers?: object, signal?: AbortSignal): Promise<VersionReturn> => {
-    return this.fetch(this.url('Version'), createHTTPRequest({}, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            version: <Version>_data.version,
-          }
+  fetchTransactionReceipt = (
+    req: FetchTransactionReceiptRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<FetchTransactionReceiptResponse> => {
+    return this.fetch(this.url('FetchTransactionReceipt'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<FetchTransactionReceiptResponse>(_data, 'FetchTransactionReceiptResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  runtimeStatus = (headers?: object, signal?: AbortSignal): Promise<RuntimeStatusReturn> => {
-    return this.fetch(this.url('RuntimeStatus'), createHTTPRequest({}, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <RuntimeStatus>_data.status,
-          }
+  fetchTransactionReceiptWithFilter = (
+    req: FetchTransactionReceiptWithFilterRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<FetchTransactionReceiptWithFilterResponse> => {
+    return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<FetchTransactionReceiptWithFilterResponse>(_data, 'FetchTransactionReceiptWithFilterResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getChainID = (headers?: object, signal?: AbortSignal): Promise<GetChainIDReturn> => {
-    return this.fetch(this.url('GetChainID'), createHTTPRequest({}, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            chainID: <number>_data.chainID,
-          }
+  getAllWebhookListeners = (
+    req: GetAllWebhookListenersRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetAllWebhookListenersResponse> => {
+    return this.fetch(this.url('GetAllWebhookListeners'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetAllWebhookListenersResponse>(_data, 'GetAllWebhookListenersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getEtherBalance = (
-    args: GetEtherBalanceArgs,
+  getBalanceUpdates = (
+    req: GetBalanceUpdatesRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetEtherBalanceReturn> => {
-    return this.fetch(this.url('GetEtherBalance'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            balance: <EtherBalance>_data.balance,
-          }
+    signal?: AbortSignal
+  ): Promise<GetBalanceUpdatesResponse> => {
+    return this.fetch(this.url('GetBalanceUpdates'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetBalanceUpdatesResponse>(_data, 'GetBalanceUpdatesResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getNativeTokenBalance = (
-    args: GetNativeTokenBalanceArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetNativeTokenBalanceReturn> => {
-    return this.fetch(this.url('GetNativeTokenBalance'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            balance: <NativeTokenBalance>_data.balance,
-          }
+  getChainID = (headers?: object, signal?: AbortSignal): Promise<GetChainIDResponse> => {
+    return this.fetch(this.url('GetChainID'), createHttpRequest('{}', headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetChainIDResponse>(_data, 'GetChainIDResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
+    )
+  }
+
+  getEtherBalance = (req: GetEtherBalanceRequest, headers?: object, signal?: AbortSignal): Promise<GetEtherBalanceResponse> => {
+    return this.fetch(this.url('GetEtherBalance'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetEtherBalanceResponse>(_data, 'GetEtherBalanceResponse')
+        })
       },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenBalancesSummary = (
-    args: GetTokenBalancesSummaryArgs,
+  getMarketplaceOrders = (
+    req: GetMarketplaceOrdersRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesSummaryReturn> => {
-    return this.fetch(this.url('GetTokenBalancesSummary'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            nativeBalances: <Array<NativeTokenBalance>>_data.nativeBalances,
-            balances: <Array<TokenBalance>>_data.balances,
-          }
+    signal?: AbortSignal
+  ): Promise<GetMarketplaceOrdersResponse> => {
+    return this.fetch(this.url('GetMarketplaceOrders'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetMarketplaceOrdersResponse>(_data, 'GetMarketplaceOrdersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenBalancesDetails = (
-    args: GetTokenBalancesDetailsArgs,
+  getMarketplaceTopOrders = (
+    req: GetMarketplaceTopOrdersRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesDetailsReturn> => {
-    return this.fetch(this.url('GetTokenBalancesDetails'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            nativeBalances: <Array<NativeTokenBalance>>_data.nativeBalances,
-            balances: <Array<TokenBalance>>_data.balances,
-          }
+    signal?: AbortSignal
+  ): Promise<GetMarketplaceTopOrdersResponse> => {
+    return this.fetch(this.url('GetMarketplaceTopOrders'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetMarketplaceTopOrdersResponse>(_data, 'GetMarketplaceTopOrdersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenBalancesByContract = (
-    args: GetTokenBalancesByContractArgs,
+  getNativeTokenBalance = (
+    req: GetNativeTokenBalanceRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesByContractReturn> => {
-    return this.fetch(this.url('GetTokenBalancesByContract'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            balances: <Array<TokenBalance>>_data.balances,
-          }
+    signal?: AbortSignal
+  ): Promise<GetNativeTokenBalanceResponse> => {
+    return this.fetch(this.url('GetNativeTokenBalance'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetNativeTokenBalanceResponse>(_data, 'GetNativeTokenBalanceResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
   getTokenBalances = (
-    args: GetTokenBalancesArgs,
+    req: GetTokenBalancesRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenBalancesReturn> => {
-    return this.fetch(this.url('GetTokenBalances'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            balances: <Array<TokenBalance>>_data.balances,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesResponse> => {
+    return this.fetch(this.url('GetTokenBalances'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenBalancesResponse>(_data, 'GetTokenBalancesResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenSupplies = (
-    args: GetTokenSuppliesArgs,
+  getTokenBalancesByContract = (
+    req: GetTokenBalancesByContractRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenSuppliesReturn> => {
-    return this.fetch(this.url('GetTokenSupplies'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            contractType: <ContractType>_data.contractType,
-            tokenIDs: <Array<TokenSupply>>_data.tokenIDs,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesByContractResponse> => {
+    return this.fetch(this.url('GetTokenBalancesByContract'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenBalancesByContractResponse>(_data, 'GetTokenBalancesByContractResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenSuppliesMap = (
-    args: GetTokenSuppliesMapArgs,
+  getTokenBalancesDetails = (
+    req: GetTokenBalancesDetailsRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenSuppliesMapReturn> => {
-    return this.fetch(this.url('GetTokenSuppliesMap'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            supplies: <{ [key: string]: Array<TokenSupply> }>_data.supplies,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesDetailsResponse> => {
+    return this.fetch(this.url('GetTokenBalancesDetails'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenBalancesDetailsResponse>(_data, 'GetTokenBalancesDetailsResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTokenIDs = (args: GetTokenIDsArgs, headers?: object, signal?: AbortSignal): Promise<GetTokenIDsReturn> => {
-    return this.fetch(this.url('GetTokenIDs'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            contractType: <ContractType>_data.contractType,
-            tokenIDs: <Array<string>>_data.tokenIDs,
-          }
+  getTokenBalancesSummary = (
+    req: GetTokenBalancesSummaryRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenBalancesSummaryResponse> => {
+    return this.fetch(this.url('GetTokenBalancesSummary'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenBalancesSummaryResponse>(_data, 'GetTokenBalancesSummaryResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
   getTokenIDRanges = (
-    args: GetTokenIDRangesArgs,
+    req: GetTokenIDRangesRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTokenIDRangesReturn> => {
-    return this.fetch(this.url('GetTokenIDRanges'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            contractType: <ContractType>_data.contractType,
-            tokenIDRanges: <Array<TokenIDRange>>_data.tokenIDRanges,
-            moreRanges: <boolean>_data.moreRanges,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTokenIDRangesResponse> => {
+    return this.fetch(this.url('GetTokenIDRanges'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenIDRangesResponse>(_data, 'GetTokenIDRangesResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getBalanceUpdates = (
-    args: GetBalanceUpdatesArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetBalanceUpdatesReturn> => {
-    return this.fetch(this.url('GetBalanceUpdates'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            balances: <Array<TokenBalance>>_data.balances,
-          }
+  getTokenIDs = (req: GetTokenIDsRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenIDsResponse> => {
+    return this.fetch(this.url('GetTokenIDs'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenIDsResponse>(_data, 'GetTokenIDsResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTransactionHistory = (
-    args: GetTransactionHistoryArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetTransactionHistoryReturn> => {
-    return this.fetch(this.url('GetTransactionHistory'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            transactions: <Array<Transaction>>_data.transactions,
-          }
+  getTokenPrice = (req: GetTokenPriceRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenPriceResponse> => {
+    return this.fetch(this.url('GetTokenPrice'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenPriceResponse>(_data, 'GetTokenPriceResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  fetchTransactionReceipt = (
-    args: FetchTransactionReceiptArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<FetchTransactionReceiptReturn> => {
-    return this.fetch(this.url('FetchTransactionReceipt'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            receipt: <TransactionReceipt>_data.receipt,
-          }
+  getTokenPrices = (req: GetTokenPricesRequest, headers?: object, signal?: AbortSignal): Promise<GetTokenPricesResponse> => {
+    return this.fetch(this.url('GetTokenPrices'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenPricesResponse>(_data, 'GetTokenPricesResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  fetchTransactionReceiptWithFilter = (
-    args: FetchTransactionReceiptWithFilterArgs,
+  getTokenSupplies = (
+    req: GetTokenSuppliesRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<FetchTransactionReceiptWithFilterReturn> => {
-    return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            receipt: <TransactionReceipt>_data.receipt,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTokenSuppliesResponse> => {
+    return this.fetch(this.url('GetTokenSupplies'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenSuppliesResponse>(_data, 'GetTokenSuppliesResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  subscribeReceipts = (
-    args: SubscribeReceiptsArgs,
-    options: WebrpcStreamOptions<SubscribeReceiptsReturn>,
-  ): Promise<void> => {
-    const _fetch = () =>
-      this.fetch(this.url('SubscribeReceipts'), createHTTPRequest(args, options.headers, options.signal)).then(
-        async (res) => {
-          await sseResponse(res, options, _fetch)
-        },
-        (error) => {
-          options.onError(error, _fetch)
-        },
-      )
-    return _fetch()
-  }
-  subscribeEvents = (args: SubscribeEventsArgs, options: WebrpcStreamOptions<SubscribeEventsReturn>): Promise<void> => {
-    const _fetch = () =>
-      this.fetch(this.url('SubscribeEvents'), createHTTPRequest(args, options.headers, options.signal)).then(
-        async (res) => {
-          await sseResponse(res, options, _fetch)
-        },
-        (error) => {
-          options.onError(error, _fetch)
-        },
-      )
-    return _fetch()
-  }
-  subscribeBalanceUpdates = (
-    args: SubscribeBalanceUpdatesArgs,
-    options: WebrpcStreamOptions<SubscribeBalanceUpdatesReturn>,
-  ): Promise<void> => {
-    const _fetch = () =>
-      this.fetch(this.url('SubscribeBalanceUpdates'), createHTTPRequest(args, options.headers, options.signal)).then(
-        async (res) => {
-          await sseResponse(res, options, _fetch)
-        },
-        (error) => {
-          options.onError(error, _fetch)
-        },
-      )
-    return _fetch()
-  }
-  syncBalance = (args: SyncBalanceArgs, headers?: object, signal?: AbortSignal): Promise<SyncBalanceReturn> => {
-    return this.fetch(this.url('SyncBalance'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {}
+  getTokenSuppliesMap = (
+    req: GetTokenSuppliesMapRequest,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTokenSuppliesMapResponse> => {
+    return this.fetch(this.url('GetTokenSuppliesMap'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTokenSuppliesMapResponse>(_data, 'GetTokenSuppliesMapResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getAllWebhookListeners = (
-    args: GetAllWebhookListenersArgs,
+  getTransactionHistory = (
+    req: GetTransactionHistoryRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetAllWebhookListenersReturn> => {
-    return this.fetch(this.url('GetAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            listeners: <Array<WebhookListener>>_data.listeners,
-          }
+    signal?: AbortSignal
+  ): Promise<GetTransactionHistoryResponse> => {
+    return this.fetch(this.url('GetTransactionHistory'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetTransactionHistoryResponse>(_data, 'GetTransactionHistoryResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
   getWebhookListener = (
-    args: GetWebhookListenerArgs,
+    req: GetWebhookListenerRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetWebhookListenerReturn> => {
-    return this.fetch(this.url('GetWebhookListener'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            listener: <WebhookListener>_data.listener,
-          }
+    signal?: AbortSignal
+  ): Promise<GetWebhookListenerResponse> => {
+    return this.fetch(this.url('GetWebhookListener'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<GetWebhookListenerResponse>(_data, 'GetWebhookListenerResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
+    )
+  }
+
+  listTokenPrices = (req: ListTokenPricesRequest, headers?: object, signal?: AbortSignal): Promise<ListTokenPricesResponse> => {
+    return this.fetch(this.url('ListTokenPrices'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<ListTokenPricesResponse>(_data, 'ListTokenPricesResponse')
+        })
       },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  addWebhookListener = (
-    args: AddWebhookListenerArgs,
+  pauseAllWebhookListeners = (
+    req: PauseAllWebhookListenersRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<AddWebhookListenerReturn> => {
-    return this.fetch(this.url('AddWebhookListener'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-            listener: <WebhookListener>_data.listener,
-          }
+    signal?: AbortSignal
+  ): Promise<PauseAllWebhookListenersResponse> => {
+    return this.fetch(this.url('PauseAllWebhookListeners'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<PauseAllWebhookListenersResponse>(_data, 'PauseAllWebhookListenersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
+    )
+  }
+
+  ping = (headers?: object, signal?: AbortSignal): Promise<PingResponse> => {
+    return this.fetch(this.url('Ping'), createHttpRequest('{}', headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<PingResponse>(_data, 'PingResponse')
+        })
       },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  updateWebhookListener = (
-    args: UpdateWebhookListenerArgs,
+  removeAllWebhookListeners = (
+    req: RemoveAllWebhookListenersRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<UpdateWebhookListenerReturn> => {
-    return this.fetch(this.url('UpdateWebhookListener'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+    signal?: AbortSignal
+  ): Promise<RemoveAllWebhookListenersResponse> => {
+    return this.fetch(this.url('RemoveAllWebhookListeners'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<RemoveAllWebhookListenersResponse>(_data, 'RemoveAllWebhookListenersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
   removeWebhookListener = (
-    args: RemoveWebhookListenerArgs,
+    req: RemoveWebhookListenerRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<RemoveWebhookListenerReturn> => {
-    return this.fetch(this.url('RemoveWebhookListener'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+    signal?: AbortSignal
+  ): Promise<RemoveWebhookListenerResponse> => {
+    return this.fetch(this.url('RemoveWebhookListener'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<RemoveWebhookListenerResponse>(_data, 'RemoveWebhookListenerResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  removeAllWebhookListeners = (
-    args: RemoveAllWebhookListenersArgs,
+  resumeAllWebhookListeners = (
+    req: ResumeAllWebhookListenersRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<RemoveAllWebhookListenersReturn> => {
-    return this.fetch(this.url('RemoveAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+    signal?: AbortSignal
+  ): Promise<ResumeAllWebhookListenersResponse> => {
+    return this.fetch(this.url('ResumeAllWebhookListeners'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<ResumeAllWebhookListenersResponse>(_data, 'ResumeAllWebhookListenersResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  toggleWebhookListener = (
-    args: ToggleWebhookListenerArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<ToggleWebhookListenerReturn> => {
-    return this.fetch(this.url('ToggleWebhookListener'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            webhookListener: <WebhookListener>_data.webhookListener,
-          }
+  runtimeStatus = (headers?: object, signal?: AbortSignal): Promise<RuntimeStatusResponse> => {
+    return this.fetch(this.url('RuntimeStatus'), createHttpRequest('{}', headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<RuntimeStatusResponse>(_data, 'RuntimeStatusResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  pauseAllWebhookListeners = (
-    args: PauseAllWebhookListenersArgs,
-    headers?: object,
-    signal?: AbortSignal,
-  ): Promise<PauseAllWebhookListenersReturn> => {
-    return this.fetch(this.url('PauseAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+  subscribeBalanceUpdates = (
+    req: SubscribeBalanceUpdatesRequest,
+    options: WebrpcStreamOptions<SubscribeBalanceUpdatesResponse>
+  ): WebrpcStreamController => {
+    const abortController = new AbortController()
+    const abortSignal = abortController.signal
+
+    if (options.signal) {
+      abortSignal.addEventListener('abort', () => abortController.abort(options.signal?.reason), {
+        signal: options.signal
+      })
+    }
+
+    const _fetch = () =>
+      this.fetch(this.url('SubscribeBalanceUpdates'), createHttpRequest(JsonEncode(req), options.headers, abortSignal)).then(
+        async res => {
+          await sseResponse(res, options, _fetch)
+        },
+        error => {
+          options.onError(error, _fetch)
+        }
+      )
+
+    const resp = _fetch()
+    return {
+      abort: abortController.abort.bind(abortController),
+      closed: resp
+    }
+  }
+  subscribeEvents = (
+    req: SubscribeEventsRequest,
+    options: WebrpcStreamOptions<SubscribeEventsResponse>
+  ): WebrpcStreamController => {
+    const abortController = new AbortController()
+    const abortSignal = abortController.signal
+
+    if (options.signal) {
+      abortSignal.addEventListener('abort', () => abortController.abort(options.signal?.reason), {
+        signal: options.signal
+      })
+    }
+
+    const _fetch = () =>
+      this.fetch(this.url('SubscribeEvents'), createHttpRequest(JsonEncode(req), options.headers, abortSignal)).then(
+        async res => {
+          await sseResponse(res, options, _fetch)
+        },
+        error => {
+          options.onError(error, _fetch)
+        }
+      )
+
+    const resp = _fetch()
+    return {
+      abort: abortController.abort.bind(abortController),
+      closed: resp
+    }
+  }
+  subscribeReceipts = (
+    req: SubscribeReceiptsRequest,
+    options: WebrpcStreamOptions<SubscribeReceiptsResponse>
+  ): WebrpcStreamController => {
+    const abortController = new AbortController()
+    const abortSignal = abortController.signal
+
+    if (options.signal) {
+      abortSignal.addEventListener('abort', () => abortController.abort(options.signal?.reason), {
+        signal: options.signal
+      })
+    }
+
+    const _fetch = () =>
+      this.fetch(this.url('SubscribeReceipts'), createHttpRequest(JsonEncode(req), options.headers, abortSignal)).then(
+        async res => {
+          await sseResponse(res, options, _fetch)
+        },
+        error => {
+          options.onError(error, _fetch)
+        }
+      )
+
+    const resp = _fetch()
+    return {
+      abort: abortController.abort.bind(abortController),
+      closed: resp
+    }
+  }
+  syncBalance = (req: SyncBalanceRequest, headers?: object, signal?: AbortSignal): Promise<SyncBalanceResponse> => {
+    return this.fetch(this.url('SyncBalance'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<SyncBalanceResponse>(_data, 'SyncBalanceResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  resumeAllWebhookListeners = (
-    args: ResumeAllWebhookListenersArgs,
+  toggleWebhookListener = (
+    req: ToggleWebhookListenerRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<ResumeAllWebhookListenersReturn> => {
-    return this.fetch(this.url('ResumeAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            status: <boolean>_data.status,
-          }
+    signal?: AbortSignal
+  ): Promise<ToggleWebhookListenerResponse> => {
+    return this.fetch(this.url('ToggleWebhookListener'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<ToggleWebhookListenerResponse>(_data, 'ToggleWebhookListenerResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getOrderbookOrders = (
-    args: GetOrderbookOrdersArgs,
+  updateWebhookListener = (
+    req: UpdateWebhookListenerRequest,
     headers?: object,
-    signal?: AbortSignal,
-  ): Promise<GetOrderbookOrdersReturn> => {
-    return this.fetch(this.url('GetOrderbookOrders'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            page: <Page>_data.page,
-            orders: <Array<OrderbookOrder>>_data.orders,
-          }
+    signal?: AbortSignal
+  ): Promise<UpdateWebhookListenerResponse> => {
+    return this.fetch(this.url('UpdateWebhookListener'), createHttpRequest(JsonEncode(req), headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<UpdateWebhookListenerResponse>(_data, 'UpdateWebhookListenerResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 
-  getTopOrders = (args: GetTopOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetTopOrdersReturn> => {
-    return this.fetch(this.url('GetTopOrders'), createHTTPRequest(args, headers, signal)).then(
-      (res) => {
-        return buildResponse(res).then((_data) => {
-          return {
-            orders: <Array<OrderbookOrder>>_data.orders,
-          }
+  version = (headers?: object, signal?: AbortSignal): Promise<VersionResponse> => {
+    return this.fetch(this.url('Version'), createHttpRequest('{}', headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return JsonDecode<VersionResponse>(_data, 'VersionResponse')
         })
       },
-      (error) => {
-        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error instanceof Error ? error.message : String(error)}` })
+      }
     )
   }
 }
@@ -1611,9 +1963,9 @@ const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, ret
     onError(
       WebrpcBadResponseError.new({
         status: res.status,
-        cause: 'Invalid response, missing body',
+        cause: 'Invalid response, missing body'
       }),
-      retryFetch,
+      retryFetch
     )
     return
   }
@@ -1643,27 +1995,22 @@ const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, ret
       lastReadTime = Date.now()
       buffer += decoder.decode(value, { stream: true })
     } catch (error) {
-      let message = ''
-      if (error instanceof Error) {
-        message = error.message
-      }
-
       if (error instanceof DOMException && error.name === 'AbortError') {
         onError(
-          WebrpcRequestFailedError.new({
+          WebrpcClientAbortedError.new({
             message: 'AbortError',
-            cause: `AbortError: ${message}`,
+            cause: `AbortError: ${error instanceof Error ? error.message : String(error)}`
           }),
           () => {
             throw new Error('Abort signal cannot be used to reconnect')
-          },
+          }
         )
       } else {
         onError(
           WebrpcStreamLostError.new({
-            cause: `reader.read(): ${message}`,
+            cause: `reader.read(): ${error instanceof Error ? error.message : String(error)}`
           }),
-          retryFetch,
+          retryFetch
         )
       }
       return
@@ -1671,12 +2018,13 @@ const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, ret
 
     let lines = buffer.split('\n')
     for (let i = 0; i < lines.length - 1; i++) {
-      if (lines[i]!.length == 0) {
+      const line = lines[i]
+      if (line?.length === 0) {
         continue
       }
       let data: any
       try {
-        data = JSON.parse(lines[i]!)
+        data = JSON.parse(line)
         if (data.hasOwnProperty('webrpcError')) {
           const error = data.webrpcError
           const code: number = typeof error.code === 'number' ? error.code : 0
@@ -1690,17 +2038,17 @@ const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, ret
         onError(
           WebrpcBadResponseError.new({
             status: res.status,
-            // @ts-ignore
-            cause: `JSON.parse(): ${error.message}`,
+            cause: `JSON.parse(): ${error instanceof Error ? error.message : String(error)}`
           }),
-          retryFetch,
+          retryFetch
         )
       }
       onMessage(data)
     }
 
     if (!done) {
-      buffer = lines[lines.length - 1]!
+      const lastLine = lines[lines.length - 1]
+      buffer = lastLine || ''
       continue
     }
 
@@ -1709,31 +2057,24 @@ const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, ret
   }
 }
 
-const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
-  const reqHeaders: { [key: string]: string } = { ...headers, 'Content-Type': 'application/json' }
-  reqHeaders[WebrpcHeader] = WebrpcHeaderValue
-
-  return {
-    method: 'POST',
-    headers: reqHeaders,
-    body: JSON.stringify(body || {}),
-    signal,
+const createHttpRequest = (body: string = '{}', headers: object = {}, signal: AbortSignal | null = null): object => {
+  const reqHeaders: { [key: string]: string } = {
+    ...headers,
+    'Content-Type': 'application/json',
+    [WebrpcHeader]: WebrpcHeaderValue
   }
+  return { method: 'POST', headers: reqHeaders, body, signal }
 }
 
 const buildResponse = (res: Response): Promise<any> => {
-  return res.text().then((text) => {
+  return res.text().then(text => {
     let data
     try {
       data = JSON.parse(text)
     } catch (error) {
-      let message = ''
-      if (error instanceof Error) {
-        message = error.message
-      }
       throw WebrpcBadResponseError.new({
         status: res.status,
-        cause: `JSON.parse(): ${message}: response text: ${text}`,
+        cause: `JSON.parse(): ${error instanceof Error ? error.message : String(error)}: response text: ${text}`
       })
     }
     if (!res.ok) {
@@ -1744,518 +2085,511 @@ const buildResponse = (res: Response): Promise<any> => {
   })
 }
 
+export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>
+
+export interface WebrpcStreamOptions<T> extends WebrpcOptions {
+  onMessage: (message: T) => void
+  onError: (error: WebrpcError, reconnect: () => void) => void
+  onOpen?: () => void
+  onClose?: () => void
+}
+
+export interface WebrpcOptions {
+  headers?: HeadersInit
+  signal?: AbortSignal
+}
+
+export interface WebrpcStreamController {
+  abort: (reason?: any) => void
+  closed: Promise<void>
+}
+
+export const JsonEncode = <T = any>(obj: T): string => {
+  return JSON.stringify(obj)
+}
+
+export const JsonDecode = <T = any>(data: string | any, _typ: string = ''): T => {
+  let parsed: any = data
+  if (typeof data === 'string') {
+    try {
+      parsed = JSON.parse(data)
+    } catch (err) {
+      throw WebrpcBadResponseError.new({ cause: `JsonDecode: JSON.parse failed: ${(err as Error).message}` })
+    }
+  }
+  return parsed as T
+}
+
 //
 // Errors
 //
 
+type WebrpcErrorParams = { name?: string; code?: number; message?: string; status?: number; cause?: string }
+
 export class WebrpcError extends Error {
-  name: string
   code: number
-  message: string
   status: number
-  cause?: string
-
-  /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
-  msg: string
-
-  constructor(name: string, code: number, message: string, status: number, cause?: string) {
-    super(message)
-    this.name = name || 'WebrpcError'
-    this.code = typeof code === 'number' ? code : 0
-    this.message = message || `endpoint error ${this.code}`
-    this.msg = this.message
-    this.status = typeof status === 'number' ? status : 0
-    this.cause = cause
+
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error.message)
+    this.name = error.name || 'WebrpcEndpointError'
+    this.code = typeof error.code === 'number' ? error.code : 0
+    this.message = error.message || `endpoint error`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcError.prototype)
   }
 
   static new(payload: any): WebrpcError {
-    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause)
+    return new this({ message: payload.message, code: payload.code, status: payload.status, cause: payload.cause })
   }
 }
 
-// Webrpc errors
-
 export class WebrpcEndpointError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcEndpoint',
-    code: number = 0,
-    message: string = 'endpoint error',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcEndpoint'
+    this.code = typeof error.code === 'number' ? error.code : 0
+    this.message = error.message || `endpoint error`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcEndpointError.prototype)
   }
 }
 
 export class WebrpcRequestFailedError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcRequestFailed',
-    code: number = -1,
-    message: string = 'request failed',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcRequestFailed'
+    this.code = typeof error.code === 'number' ? error.code : -1
+    this.message = error.message || `request failed`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype)
   }
 }
 
 export class WebrpcBadRouteError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcBadRoute',
-    code: number = -2,
-    message: string = 'bad route',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcBadRoute'
+    this.code = typeof error.code === 'number' ? error.code : -2
+    this.message = error.message || `bad route`
+    this.status = typeof error.status === 'number' ? error.status : 404
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcBadRouteError.prototype)
   }
 }
 
 export class WebrpcBadMethodError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcBadMethod',
-    code: number = -3,
-    message: string = 'bad method',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcBadMethod'
+    this.code = typeof error.code === 'number' ? error.code : -3
+    this.message = error.message || `bad method`
+    this.status = typeof error.status === 'number' ? error.status : 405
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcBadMethodError.prototype)
   }
 }
 
 export class WebrpcBadRequestError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcBadRequest',
-    code: number = -4,
-    message: string = 'bad request',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcBadRequest'
+    this.code = typeof error.code === 'number' ? error.code : -4
+    this.message = error.message || `bad request`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcBadRequestError.prototype)
   }
 }
 
 export class WebrpcBadResponseError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcBadResponse',
-    code: number = -5,
-    message: string = 'bad response',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcBadResponse'
+    this.code = typeof error.code === 'number' ? error.code : -5
+    this.message = error.message || `bad response`
+    this.status = typeof error.status === 'number' ? error.status : 500
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcBadResponseError.prototype)
   }
 }
 
 export class WebrpcServerPanicError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcServerPanic',
-    code: number = -6,
-    message: string = 'server panic',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcServerPanic'
+    this.code = typeof error.code === 'number' ? error.code : -6
+    this.message = error.message || `server panic`
+    this.status = typeof error.status === 'number' ? error.status : 500
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcServerPanicError.prototype)
   }
 }
 
 export class WebrpcInternalErrorError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcInternalError',
-    code: number = -7,
-    message: string = 'internal error',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcInternalError'
+    this.code = typeof error.code === 'number' ? error.code : -7
+    this.message = error.message || `internal error`
+    this.status = typeof error.status === 'number' ? error.status : 500
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype)
   }
 }
 
-export class WebrpcClientDisconnectedError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcClientDisconnected',
-    code: number = -8,
-    message: string = 'client disconnected',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype)
+export class WebrpcClientAbortedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcClientAborted'
+    this.code = typeof error.code === 'number' ? error.code : -8
+    this.message = error.message || `request aborted by client`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, WebrpcClientAbortedError.prototype)
   }
 }
 
 export class WebrpcStreamLostError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcStreamLost',
-    code: number = -9,
-    message: string = 'stream lost',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcStreamLost'
+    this.code = typeof error.code === 'number' ? error.code : -9
+    this.message = error.message || `stream lost`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcStreamLostError.prototype)
   }
 }
 
 export class WebrpcStreamFinishedError extends WebrpcError {
-  constructor(
-    name: string = 'WebrpcStreamFinished',
-    code: number = -10,
-    message: string = 'stream finished',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'WebrpcStreamFinished'
+    this.code = typeof error.code === 'number' ? error.code : -10
+    this.message = error.message || `stream finished`
+    this.status = typeof error.status === 'number' ? error.status : 200
+    if (error.cause !== undefined) this.cause = error.cause
     Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype)
   }
 }
 
+//
 // Schema errors
+//
 
-export class UnauthorizedError extends WebrpcError {
-  constructor(
-    name: string = 'Unauthorized',
-    code: number = 1000,
-    message: string = 'Unauthorized access',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, UnauthorizedError.prototype)
+export class AbortedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'Aborted'
+    this.code = typeof error.code === 'number' ? error.code : 1005
+    this.message = error.message || `Request aborted`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, AbortedError.prototype)
   }
 }
 
-export class PermissionDeniedError extends WebrpcError {
-  constructor(
-    name: string = 'PermissionDenied',
-    code: number = 1001,
-    message: string = 'Permission denied',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, PermissionDeniedError.prototype)
+export class AccessKeyMismatchError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'AccessKeyMismatch'
+    this.code = typeof error.code === 'number' ? error.code : 1102
+    this.message = error.message || `Access key mismatch`
+    this.status = typeof error.status === 'number' ? error.status : 409
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, AccessKeyMismatchError.prototype)
   }
 }
 
-export class SessionExpiredError extends WebrpcError {
-  constructor(
-    name: string = 'SessionExpired',
-    code: number = 1002,
-    message: string = 'Session expired',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, SessionExpiredError.prototype)
+export class AccessKeyNotFoundError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'AccessKeyNotFound'
+    this.code = typeof error.code === 'number' ? error.code : 1101
+    this.message = error.message || `Access key not found`
+    this.status = typeof error.status === 'number' ? error.status : 401
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, AccessKeyNotFoundError.prototype)
   }
 }
 
-export class MethodNotFoundError extends WebrpcError {
-  constructor(
-    name: string = 'MethodNotFound',
-    code: number = 1003,
-    message: string = 'Method not found',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, MethodNotFoundError.prototype)
+export class AtLeastOneKeyError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'AtLeastOneKey'
+    this.code = typeof error.code === 'number' ? error.code : 1302
+    this.message = error.message || `You need at least one Access Key`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, AtLeastOneKeyError.prototype)
   }
 }
 
-export class RequestConflictError extends WebrpcError {
-  constructor(
-    name: string = 'RequestConflict',
-    code: number = 1004,
-    message: string = 'Conflict with target resource',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, RequestConflictError.prototype)
+export class GeoblockedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'Geoblocked'
+    this.code = typeof error.code === 'number' ? error.code : 1006
+    this.message = error.message || `Geoblocked region`
+    this.status = typeof error.status === 'number' ? error.status : 451
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, GeoblockedError.prototype)
   }
 }
 
-export class AbortedError extends WebrpcError {
-  constructor(
-    name: string = 'Aborted',
-    code: number = 1005,
-    message: string = 'Request aborted',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, AbortedError.prototype)
+export class InvalidArgumentError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'InvalidArgument'
+    this.code = typeof error.code === 'number' ? error.code : 2001
+    this.message = error.message || `Invalid argument`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, InvalidArgumentError.prototype)
   }
 }
 
-export class GeoblockedError extends WebrpcError {
-  constructor(
-    name: string = 'Geoblocked',
-    code: number = 1006,
-    message: string = 'Geoblocked region',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, GeoblockedError.prototype)
+export class InvalidOriginError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'InvalidOrigin'
+    this.code = typeof error.code === 'number' ? error.code : 1103
+    this.message = error.message || `Invalid origin for Access Key`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, InvalidOriginError.prototype)
   }
 }
 
-export class RateLimitedError extends WebrpcError {
-  constructor(
-    name: string = 'RateLimited',
-    code: number = 1007,
-    message: string = 'Rate-limited. Please slow down.',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, RateLimitedError.prototype)
+export class InvalidServiceError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'InvalidService'
+    this.code = typeof error.code === 'number' ? error.code : 1104
+    this.message = error.message || `Service not enabled for Access key`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, InvalidServiceError.prototype)
   }
 }
 
-export class ProjectNotFoundError extends WebrpcError {
-  constructor(
-    name: string = 'ProjectNotFound',
-    code: number = 1100,
-    message: string = 'Project not found',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, ProjectNotFoundError.prototype)
+export class MaxAccessKeysError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'MaxAccessKeys'
+    this.code = typeof error.code === 'number' ? error.code : 1301
+    this.message = error.message || `Access keys limit reached`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, MaxAccessKeysError.prototype)
   }
 }
 
-export class AccessKeyNotFoundError extends WebrpcError {
-  constructor(
-    name: string = 'AccessKeyNotFound',
-    code: number = 1101,
-    message: string = 'Access key not found',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, AccessKeyNotFoundError.prototype)
+export class MetadataCallFailedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'MetadataCallFailed'
+    this.code = typeof error.code === 'number' ? error.code : 3003
+    this.message = error.message || `Metadata service call failed`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, MetadataCallFailedError.prototype)
   }
 }
 
-export class AccessKeyMismatchError extends WebrpcError {
-  constructor(
-    name: string = 'AccessKeyMismatch',
-    code: number = 1102,
-    message: string = 'Access key mismatch',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, AccessKeyMismatchError.prototype)
+export class MethodNotFoundError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'MethodNotFound'
+    this.code = typeof error.code === 'number' ? error.code : 1003
+    this.message = error.message || `Method not found`
+    this.status = typeof error.status === 'number' ? error.status : 404
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, MethodNotFoundError.prototype)
   }
 }
 
-export class InvalidOriginError extends WebrpcError {
-  constructor(
-    name: string = 'InvalidOrigin',
-    code: number = 1103,
-    message: string = 'Invalid origin for Access Key',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, InvalidOriginError.prototype)
+export class NoDefaultKeyError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'NoDefaultKey'
+    this.code = typeof error.code === 'number' ? error.code : 1300
+    this.message = error.message || `No default access key found`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, NoDefaultKeyError.prototype)
   }
 }
 
-export class InvalidServiceError extends WebrpcError {
-  constructor(
-    name: string = 'InvalidService',
-    code: number = 1104,
-    message: string = 'Service not enabled for Access key',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, InvalidServiceError.prototype)
+export class NotFoundError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'NotFound'
+    this.code = typeof error.code === 'number' ? error.code : 3000
+    this.message = error.message || `Resource not found`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, NotFoundError.prototype)
   }
 }
 
-export class UnauthorizedUserError extends WebrpcError {
-  constructor(
-    name: string = 'UnauthorizedUser',
-    code: number = 1105,
-    message: string = 'Unauthorized user',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, UnauthorizedUserError.prototype)
+export class PermissionDeniedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'PermissionDenied'
+    this.code = typeof error.code === 'number' ? error.code : 1001
+    this.message = error.message || `Permission denied`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, PermissionDeniedError.prototype)
   }
 }
 
-export class QuotaExceededError extends WebrpcError {
-  constructor(
-    name: string = 'QuotaExceeded',
-    code: number = 1200,
-    message: string = 'Quota exceeded',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, QuotaExceededError.prototype)
+export class ProjectNotFoundError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'ProjectNotFound'
+    this.code = typeof error.code === 'number' ? error.code : 1100
+    this.message = error.message || `Project not found`
+    this.status = typeof error.status === 'number' ? error.status : 401
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, ProjectNotFoundError.prototype)
   }
 }
 
-export class RateLimitError extends WebrpcError {
-  constructor(
-    name: string = 'RateLimit',
-    code: number = 1201,
-    message: string = 'Rate limit exceeded',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, RateLimitError.prototype)
+export class QueryFailedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'QueryFailed'
+    this.code = typeof error.code === 'number' ? error.code : 2003
+    this.message = error.message || `Query failed`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, QueryFailedError.prototype)
   }
 }
 
-export class NoDefaultKeyError extends WebrpcError {
-  constructor(
-    name: string = 'NoDefaultKey',
-    code: number = 1300,
-    message: string = 'No default access key found',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, NoDefaultKeyError.prototype)
+export class QuotaExceededError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'QuotaExceeded'
+    this.code = typeof error.code === 'number' ? error.code : 1200
+    this.message = error.message || `Quota exceeded`
+    this.status = typeof error.status === 'number' ? error.status : 429
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, QuotaExceededError.prototype)
   }
 }
 
-export class MaxAccessKeysError extends WebrpcError {
-  constructor(
-    name: string = 'MaxAccessKeys',
-    code: number = 1301,
-    message: string = 'Access keys limit reached',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, MaxAccessKeysError.prototype)
+export class RateLimitError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'RateLimit'
+    this.code = typeof error.code === 'number' ? error.code : 1201
+    this.message = error.message || `Rate limit exceeded`
+    this.status = typeof error.status === 'number' ? error.status : 429
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, RateLimitError.prototype)
   }
 }
 
-export class AtLeastOneKeyError extends WebrpcError {
-  constructor(
-    name: string = 'AtLeastOneKey',
-    code: number = 1302,
-    message: string = 'You need at least one Access Key',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, AtLeastOneKeyError.prototype)
+export class RateLimitedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'RateLimited'
+    this.code = typeof error.code === 'number' ? error.code : 1007
+    this.message = error.message || `Rate-limited. Please slow down.`
+    this.status = typeof error.status === 'number' ? error.status : 429
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, RateLimitedError.prototype)
   }
 }
 
-export class TimeoutError extends WebrpcError {
-  constructor(
-    name: string = 'Timeout',
-    code: number = 1900,
-    message: string = 'Request timed out',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, TimeoutError.prototype)
+export class RequestConflictError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'RequestConflict'
+    this.code = typeof error.code === 'number' ? error.code : 1004
+    this.message = error.message || `Conflict with target resource`
+    this.status = typeof error.status === 'number' ? error.status : 409
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, RequestConflictError.prototype)
   }
 }
 
-export class InvalidArgumentError extends WebrpcError {
-  constructor(
-    name: string = 'InvalidArgument',
-    code: number = 2001,
-    message: string = 'Invalid argument',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, InvalidArgumentError.prototype)
+export class ResourceExhaustedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'ResourceExhausted'
+    this.code = typeof error.code === 'number' ? error.code : 2004
+    this.message = error.message || `Resource exhausted`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, ResourceExhaustedError.prototype)
   }
 }
 
-export class UnavailableError extends WebrpcError {
-  constructor(
-    name: string = 'Unavailable',
-    code: number = 2002,
-    message: string = 'Unavailable resource',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, UnavailableError.prototype)
+export class SessionExpiredError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'SessionExpired'
+    this.code = typeof error.code === 'number' ? error.code : 1002
+    this.message = error.message || `Session expired`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, SessionExpiredError.prototype)
   }
 }
 
-export class QueryFailedError extends WebrpcError {
-  constructor(
-    name: string = 'QueryFailed',
-    code: number = 2003,
-    message: string = 'Query failed',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, QueryFailedError.prototype)
+export class TimeoutError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'Timeout'
+    this.code = typeof error.code === 'number' ? error.code : 1900
+    this.message = error.message || `Request timed out`
+    this.status = typeof error.status === 'number' ? error.status : 408
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, TimeoutError.prototype)
   }
 }
 
-export class ResourceExhaustedError extends WebrpcError {
-  constructor(
-    name: string = 'ResourceExhausted',
-    code: number = 2004,
-    message: string = 'Resource exhausted',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, ResourceExhaustedError.prototype)
+export class UnauthorizedError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'Unauthorized'
+    this.code = typeof error.code === 'number' ? error.code : 1000
+    this.message = error.message || `Unauthorized access`
+    this.status = typeof error.status === 'number' ? error.status : 401
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, UnauthorizedError.prototype)
   }
 }
 
-export class NotFoundError extends WebrpcError {
-  constructor(
-    name: string = 'NotFound',
-    code: number = 3000,
-    message: string = 'Resource not found',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, NotFoundError.prototype)
+export class UnauthorizedUserError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'UnauthorizedUser'
+    this.code = typeof error.code === 'number' ? error.code : 1105
+    this.message = error.message || `Unauthorized user`
+    this.status = typeof error.status === 'number' ? error.status : 403
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, UnauthorizedUserError.prototype)
   }
 }
 
-export class MetadataCallFailedError extends WebrpcError {
-  constructor(
-    name: string = 'MetadataCallFailed',
-    code: number = 3003,
-    message: string = 'Metadata service call failed',
-    status: number = 0,
-    cause?: string,
-  ) {
-    super(name, code, message, status, cause)
-    Object.setPrototypeOf(this, MetadataCallFailedError.prototype)
+export class UnavailableError extends WebrpcError {
+  constructor(error: WebrpcErrorParams = {}) {
+    super(error)
+    this.name = error.name || 'Unavailable'
+    this.code = typeof error.code === 'number' ? error.code : 2002
+    this.message = error.message || `Unavailable resource`
+    this.status = typeof error.status === 'number' ? error.status : 400
+    if (error.cause !== undefined) this.cause = error.cause
+    Object.setPrototypeOf(this, UnavailableError.prototype)
   }
 }
 
@@ -2268,38 +2602,78 @@ export enum errors {
   WebrpcBadResponse = 'WebrpcBadResponse',
   WebrpcServerPanic = 'WebrpcServerPanic',
   WebrpcInternalError = 'WebrpcInternalError',
-  WebrpcClientDisconnected = 'WebrpcClientDisconnected',
+  WebrpcClientAborted = 'WebrpcClientAborted',
   WebrpcStreamLost = 'WebrpcStreamLost',
   WebrpcStreamFinished = 'WebrpcStreamFinished',
-  Unauthorized = 'Unauthorized',
-  PermissionDenied = 'PermissionDenied',
-  SessionExpired = 'SessionExpired',
-  MethodNotFound = 'MethodNotFound',
-  RequestConflict = 'RequestConflict',
   Aborted = 'Aborted',
-  Geoblocked = 'Geoblocked',
-  RateLimited = 'RateLimited',
-  ProjectNotFound = 'ProjectNotFound',
-  AccessKeyNotFound = 'AccessKeyNotFound',
   AccessKeyMismatch = 'AccessKeyMismatch',
+  AccessKeyNotFound = 'AccessKeyNotFound',
+  AtLeastOneKey = 'AtLeastOneKey',
+  Geoblocked = 'Geoblocked',
+  InvalidArgument = 'InvalidArgument',
   InvalidOrigin = 'InvalidOrigin',
   InvalidService = 'InvalidService',
-  UnauthorizedUser = 'UnauthorizedUser',
-  QuotaExceeded = 'QuotaExceeded',
-  RateLimit = 'RateLimit',
-  NoDefaultKey = 'NoDefaultKey',
   MaxAccessKeys = 'MaxAccessKeys',
-  AtLeastOneKey = 'AtLeastOneKey',
-  Timeout = 'Timeout',
-  InvalidArgument = 'InvalidArgument',
-  Unavailable = 'Unavailable',
+  MetadataCallFailed = 'MetadataCallFailed',
+  MethodNotFound = 'MethodNotFound',
+  NoDefaultKey = 'NoDefaultKey',
+  NotFound = 'NotFound',
+  PermissionDenied = 'PermissionDenied',
+  ProjectNotFound = 'ProjectNotFound',
   QueryFailed = 'QueryFailed',
+  QuotaExceeded = 'QuotaExceeded',
+  RateLimit = 'RateLimit',
+  RateLimited = 'RateLimited',
+  RequestConflict = 'RequestConflict',
   ResourceExhausted = 'ResourceExhausted',
-  NotFound = 'NotFound',
-  MetadataCallFailed = 'MetadataCallFailed',
-}
-
-const webrpcErrorByCode: { [code: number]: any } = {
+  SessionExpired = 'SessionExpired',
+  Timeout = 'Timeout',
+  Unauthorized = 'Unauthorized',
+  UnauthorizedUser = 'UnauthorizedUser',
+  Unavailable = 'Unavailable'
+}
+
+export enum WebrpcErrorCodes {
+  WebrpcEndpoint = 0,
+  WebrpcRequestFailed = -1,
+  WebrpcBadRoute = -2,
+  WebrpcBadMethod = -3,
+  WebrpcBadRequest = -4,
+  WebrpcBadResponse = -5,
+  WebrpcServerPanic = -6,
+  WebrpcInternalError = -7,
+  WebrpcClientAborted = -8,
+  WebrpcStreamLost = -9,
+  WebrpcStreamFinished = -10,
+  Aborted = 1005,
+  AccessKeyMismatch = 1102,
+  AccessKeyNotFound = 1101,
+  AtLeastOneKey = 1302,
+  Geoblocked = 1006,
+  InvalidArgument = 2001,
+  InvalidOrigin = 1103,
+  InvalidService = 1104,
+  MaxAccessKeys = 1301,
+  MetadataCallFailed = 3003,
+  MethodNotFound = 1003,
+  NoDefaultKey = 1300,
+  NotFound = 3000,
+  PermissionDenied = 1001,
+  ProjectNotFound = 1100,
+  QueryFailed = 2003,
+  QuotaExceeded = 1200,
+  RateLimit = 1201,
+  RateLimited = 1007,
+  RequestConflict = 1004,
+  ResourceExhausted = 2004,
+  SessionExpired = 1002,
+  Timeout = 1900,
+  Unauthorized = 1000,
+  UnauthorizedUser = 1105,
+  Unavailable = 2002
+}
+
+export const webrpcErrorByCode: { [code: number]: any } = {
   [0]: WebrpcEndpointError,
   [-1]: WebrpcRequestFailedError,
   [-2]: WebrpcBadRouteError,
@@ -2308,46 +2682,89 @@ const webrpcErrorByCode: { [code: number]: any } = {
   [-5]: WebrpcBadResponseError,
   [-6]: WebrpcServerPanicError,
   [-7]: WebrpcInternalErrorError,
-  [-8]: WebrpcClientDisconnectedError,
+  [-8]: WebrpcClientAbortedError,
   [-9]: WebrpcStreamLostError,
   [-10]: WebrpcStreamFinishedError,
-  [1000]: UnauthorizedError,
-  [1001]: PermissionDeniedError,
-  [1002]: SessionExpiredError,
-  [1003]: MethodNotFoundError,
-  [1004]: RequestConflictError,
   [1005]: AbortedError,
-  [1006]: GeoblockedError,
-  [1007]: RateLimitedError,
-  [1100]: ProjectNotFoundError,
-  [1101]: AccessKeyNotFoundError,
   [1102]: AccessKeyMismatchError,
+  [1101]: AccessKeyNotFoundError,
+  [1302]: AtLeastOneKeyError,
+  [1006]: GeoblockedError,
+  [2001]: InvalidArgumentError,
   [1103]: InvalidOriginError,
   [1104]: InvalidServiceError,
-  [1105]: UnauthorizedUserError,
-  [1200]: QuotaExceededError,
-  [1201]: RateLimitError,
-  [1300]: NoDefaultKeyError,
   [1301]: MaxAccessKeysError,
-  [1302]: AtLeastOneKeyError,
-  [1900]: TimeoutError,
-  [2001]: InvalidArgumentError,
-  [2002]: UnavailableError,
+  [3003]: MetadataCallFailedError,
+  [1003]: MethodNotFoundError,
+  [1300]: NoDefaultKeyError,
+  [3000]: NotFoundError,
+  [1001]: PermissionDeniedError,
+  [1100]: ProjectNotFoundError,
   [2003]: QueryFailedError,
+  [1200]: QuotaExceededError,
+  [1201]: RateLimitError,
+  [1007]: RateLimitedError,
+  [1004]: RequestConflictError,
   [2004]: ResourceExhaustedError,
-  [3000]: NotFoundError,
-  [3003]: MetadataCallFailedError,
+  [1002]: SessionExpiredError,
+  [1900]: TimeoutError,
+  [1000]: UnauthorizedError,
+  [1105]: UnauthorizedUserError,
+  [2002]: UnavailableError
 }
 
-export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>
+//
+// Webrpc
+//
 
-export interface WebrpcStreamOptions<T> extends WebrpcOptions {
-  onMessage: (message: T) => void
-  onError: (error: WebrpcError, reconnect: () => void) => void
-  onOpen?: () => void
-  onClose?: () => void
+export const WebrpcHeader = 'Webrpc'
+
+export const WebrpcHeaderValue = 'webrpc@v0.31.2;gen-typescript@v0.23.1;sequence-indexer@v0.4.0'
+
+type WebrpcGenVersions = {
+  WebrpcGenVersion: string
+  codeGenName: string
+  codeGenVersion: string
+  schemaName: string
+  schemaVersion: string
 }
-export interface WebrpcOptions {
-  headers?: HeadersInit
-  signal?: AbortSignal
+
+export function VersionFromHeader(headers: Headers): WebrpcGenVersions {
+  const headerValue = headers.get(WebrpcHeader)
+  if (!headerValue) {
+    return {
+      WebrpcGenVersion: '',
+      codeGenName: '',
+      codeGenVersion: '',
+      schemaName: '',
+      schemaVersion: ''
+    }
+  }
+
+  return parseWebrpcGenVersions(headerValue)
+}
+
+function parseWebrpcGenVersions(header: string): WebrpcGenVersions {
+  const versions = header.split(';')
+  if (versions.length < 3) {
+    return {
+      WebrpcGenVersion: '',
+      codeGenName: '',
+      codeGenVersion: '',
+      schemaName: '',
+      schemaVersion: ''
+    }
+  }
+
+  const [_, WebrpcGenVersion] = versions[0]!.split('@')
+  const [codeGenName, codeGenVersion] = versions[1]!.split('@')
+  const [schemaName, schemaVersion] = versions[2]!.split('@')
+
+  return {
+    WebrpcGenVersion: WebrpcGenVersion ?? '',
+    codeGenName: codeGenName ?? '',
+    codeGenVersion: codeGenVersion ?? '',
+    schemaName: schemaName ?? '',
+    schemaVersion: schemaVersion ?? ''
+  }
 }