@0xsequence/indexer 1.9.24 → 1.9.25

package/src/indexer.gen.ts

@@ -1,9 +1,9 @@
 /* eslint-disable */
-// sequence-indexer v0.4.0 83530970d81179658f6546c87fc4352280dbd287
+// sequence-indexer v0.4.0 d33d29bc84a4439a42a4e1533035bc80c4ea226e
 // --
-// Code generated by webrpc-gen@v0.14.0-dev with typescript@v0.10.0 generator. DO NOT EDIT.
+// Code generated by webrpc-gen@v0.18.6 with typescript generator. DO NOT EDIT.
 //
-// webrpc-gen -schema=indexer.ridl -target=typescript@v0.10.0 -client -out=./clients/indexer.gen.ts
+// webrpc-gen -schema=indexer.ridl -target=typescript -client -out=./clients/indexer.gen.ts
 
 // WebRPC description and code-gen version
 export const WebRPCVersion = 'v1'
@@ -12,7 +12,7 @@ export const WebRPCVersion = 'v1'
 export const WebRPCSchemaVersion = 'v0.4.0'
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = '83530970d81179658f6546c87fc4352280dbd287'
+export const WebRPCSchemaHash = 'd33d29bc84a4439a42a4e1533035bc80c4ea226e'
 
 //
 // Types
@@ -29,7 +29,6 @@ export interface ContractInfo {
   deployed: boolean
   bytecodeHash: string
   extensions: ContractInfoExtensions
-
   updatedAt: string
 }
 
@@ -46,21 +45,36 @@ export interface ContractInfoExtensions {
 
 export interface TokenMetadata {
   tokenId: string
-  contractAddress: string
   name: string
-  description: string
-  image: string
-  decimals: number
-  properties: { [key: string]: any }
-  video: string
-  audio: string
-  image_data: string
-  external_url: string
-  background_color: string
-  animation_url: string
+  description?: string
+  image?: string
+  video?: string
+  audio?: string
+  properties?: { [key: string]: any }
   attributes: Array<{ [key: string]: any }>
-  updatedAt: string
+  image_data?: string
+  external_url?: string
+  background_color?: string
+  animation_url?: string
+  decimals?: number
+  updatedAt?: string
+  assets?: Array<Asset>
+}
+
+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 ContractType {
   UNKNOWN = 'UNKNOWN',
   NATIVE = 'NATIVE',
@@ -73,36 +87,43 @@ export enum ContractType {
   ERC1155_BRIDGE = 'ERC1155_BRIDGE',
   SEQ_MARKETPLACE = 'SEQ_MARKETPLACE'
 }
+
 export enum EventLogType {
   UNKNOWN = 'UNKNOWN',
   BLOCK_ADDED = 'BLOCK_ADDED',
   BLOCK_REMOVED = 'BLOCK_REMOVED'
 }
+
 export enum EventLogDataType {
   UNKNOWN = 'UNKNOWN',
   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 TxnTransferType {
   UNKNOWN = 'UNKNOWN',
   SEND = 'SEND',
   RECEIVE = 'RECEIVE'
 }
+
 export enum TransactionStatus {
   FAILED = 'FAILED',
   SUCCESSFUL = 'SUCCESSFUL'
 }
+
 export enum TransactionType {
   LegacyTxnType = 'LegacyTxnType',
   AccessListTxnType = 'AccessListTxnType',
   DynamicFeeTxnType = 'DynamicFeeTxnType'
 }
+
 export enum SortOrder {
   DESC = 'DESC',
   ASC = 'ASC'
@@ -148,7 +169,15 @@ export interface RuntimeChecks {
   lastBlockNumWithState: number
   bloomStatus: BloomStatus
   bond: Bond
-  diskUsage: string
+  diskUsage: DiskUsage
+}
+
+export interface DiskUsage {
+  humanReadable: string
+  used: number
+  size: number
+  percent: number
+  dirs: { [key: string]: string }
 }
 
 export interface Bond {
@@ -219,7 +248,6 @@ export interface TokenBalance {
   blockHash: string
   blockNumber: number
   chainId: number
-
   contractInfo?: ContractInfo
   tokenMetadata?: TokenMetadata
 }
@@ -307,12 +335,13 @@ export interface TransactionHistoryFilter {
   tokenID?: string
 }
 
-export interface Filter {
+export interface TransactionFilter {
   txnHash?: string
   from?: string
   to?: string
   contractAddress?: string
-  logTopic?: string
+  event?: string
+  topicHash?: string
 }
 
 export interface TransactionReceipt {
@@ -357,11 +386,13 @@ export interface WebhookListener {
   id: number
   projectID: number
   url: string
-  filters: WebhookEventFilter
+  filters: EventFilter
   updatedAt: string
 }
 
-export interface WebhookEventFilter {
+export interface EventFilter {
+  events?: Array<string>
+  topicHashes?: Array<string>
   contractAddresses?: Array<string>
   tokenIDs?: Array<string>
   accounts?: Array<string>
@@ -374,29 +405,52 @@ export interface MetadataOptions {
 }
 
 export interface Indexer {
-  ping(headers?: object): Promise<PingReturn>
-  version(headers?: object): Promise<VersionReturn>
-  runtimeStatus(headers?: object): Promise<RuntimeStatusReturn>
-  getChainID(headers?: object): Promise<GetChainIDReturn>
-  getEtherBalance(args: GetEtherBalanceArgs, headers?: object): Promise<GetEtherBalanceReturn>
-  getTokenBalances(args: GetTokenBalancesArgs, headers?: object): Promise<GetTokenBalancesReturn>
-  getTokenSupplies(args: GetTokenSuppliesArgs, headers?: object): Promise<GetTokenSuppliesReturn>
-  getTokenSuppliesMap(args: GetTokenSuppliesMapArgs, headers?: object): Promise<GetTokenSuppliesMapReturn>
-  getBalanceUpdates(args: GetBalanceUpdatesArgs, headers?: object): Promise<GetBalanceUpdatesReturn>
-  getTransactionHistory(args: GetTransactionHistoryArgs, headers?: object): Promise<GetTransactionHistoryReturn>
-  syncBalance(args: SyncBalanceArgs, headers?: object): Promise<SyncBalanceReturn>
-  fetchTransactionReceipt(args: FetchTransactionReceiptArgs, headers?: object): Promise<FetchTransactionReceiptReturn>
-  getOrderbookOrders(args: GetOrderbookOrdersArgs, headers?: object): Promise<GetOrderbookOrdersReturn>
-  getTopOrders(args: GetTopOrdersArgs, headers?: object): Promise<GetTopOrdersReturn>
+  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>
+  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>
+  getBalanceUpdates(args: GetBalanceUpdatesArgs, headers?: object, signal?: AbortSignal): Promise<GetBalanceUpdatesReturn>
+  getTransactionHistory(
+    args: GetTransactionHistoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetTransactionHistoryReturn>
+  syncBalance(args: SyncBalanceArgs, headers?: object, signal?: AbortSignal): Promise<SyncBalanceReturn>
+  fetchTransactionReceipt(
+    args: FetchTransactionReceiptArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<FetchTransactionReceiptReturn>
+  getOrderbookOrders(args: GetOrderbookOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetOrderbookOrdersReturn>
+  getTopOrders(args: GetTopOrdersArgs, headers?: object, signal?: AbortSignal): Promise<GetTopOrdersReturn>
   fetchTransactionReceiptWithFilter(
     args: FetchTransactionReceiptWithFilterArgs,
-    headers?: object
+    headers?: object,
+    signal?: AbortSignal
   ): Promise<FetchTransactionReceiptWithFilterReturn>
-  getAllWebhookListeners(args: GetAllWebhookListenersArgs, headers?: object): Promise<GetAllWebhookListenersReturn>
-  getWebhookListener(args: GetWebhookListenerArgs, headers?: object): Promise<GetWebhookListenerReturn>
-  addWebhookListener(args: AddWebhookListenerArgs, headers?: object): Promise<AddWebhookListenerReturn>
-  updateWebhookListener(args: UpdateWebhookListenerArgs, headers?: object): Promise<UpdateWebhookListenerReturn>
-  removeWebhookListener(args: RemoveWebhookListenerArgs, headers?: object): Promise<RemoveWebhookListenerReturn>
+  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>
+  subscribeReceipts(args: SubscribeReceiptsArgs, options: WebrpcStreamOptions<SubscribeReceiptsReturn>): Promise<void>
+  subscribeEvents(args: SubscribeEventsArgs, options: WebrpcStreamOptions<SubscribeEventsReturn>): Promise<void>
 }
 
 export interface PingArgs {}
@@ -526,7 +580,7 @@ export interface GetTopOrdersReturn {
   orders: Array<OrderbookOrder>
 }
 export interface FetchTransactionReceiptWithFilterArgs {
-  filter: Filter
+  filter: TransactionFilter
   maxBlockWait?: number
 }
 
@@ -550,7 +604,7 @@ export interface GetWebhookListenerReturn {
 }
 export interface AddWebhookListenerArgs {
   url: string
-  filters: WebhookEventFilter
+  filters: EventFilter
   projectId?: number
 }
 
@@ -574,6 +628,20 @@ export interface RemoveWebhookListenerArgs {
 export interface RemoveWebhookListenerReturn {
   status: boolean
 }
+export interface SubscribeReceiptsArgs {
+  filter: TransactionFilter
+}
+
+export interface SubscribeReceiptsReturn {
+  receipt: TransactionReceipt
+}
+export interface SubscribeEventsArgs {
+  filter: EventFilter
+}
+
+export interface SubscribeEventsReturn {
+  log: EventLog
+}
 
 //
 // Client
@@ -592,226 +660,507 @@ export class Indexer implements Indexer {
     return this.hostname + this.path + name
   }
 
-  ping = (headers?: object): Promise<PingReturn> => {
-    return this.fetch(this.url('Ping'), createHTTPRequest({}, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>_data.status
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  version = (headers?: object): Promise<VersionReturn> => {
-    return this.fetch(this.url('Version'), createHTTPRequest({}, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          version: <Version>_data.version
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  runtimeStatus = (headers?: object): Promise<RuntimeStatusReturn> => {
-    return this.fetch(this.url('RuntimeStatus'), createHTTPRequest({}, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <RuntimeStatus>_data.status
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getChainID = (headers?: object): Promise<GetChainIDReturn> => {
-    return this.fetch(this.url('GetChainID'), createHTTPRequest({}, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          chainID: <number>_data.chainID
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getEtherBalance = (args: GetEtherBalanceArgs, headers?: object): Promise<GetEtherBalanceReturn> => {
-    return this.fetch(this.url('GetEtherBalance'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          balance: <EtherBalance>_data.balance
-        }
-      })
-    })
+  getEtherBalance = (args: GetEtherBalanceArgs, 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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getTokenBalances = (args: GetTokenBalancesArgs, headers?: object): Promise<GetTokenBalancesReturn> => {
-    return this.fetch(this.url('GetTokenBalances'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>_data.page,
-          balances: <Array<TokenBalance>>_data.balances
-        }
-      })
-    })
+  getTokenBalances = (args: GetTokenBalancesArgs, 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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getTokenSupplies = (args: GetTokenSuppliesArgs, headers?: object): Promise<GetTokenSuppliesReturn> => {
-    return this.fetch(this.url('GetTokenSupplies'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>_data.page,
-          contractType: <ContractType>_data.contractType,
-          tokenIDs: <Array<TokenSupply>>_data.tokenIDs
-        }
-      })
-    })
+  getTokenSupplies = (args: GetTokenSuppliesArgs, 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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getTokenSuppliesMap = (args: GetTokenSuppliesMapArgs, headers?: object): Promise<GetTokenSuppliesMapReturn> => {
-    return this.fetch(this.url('GetTokenSuppliesMap'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          supplies: <{ [key: string]: Array<TokenSupply> }>_data.supplies
-        }
-      })
-    })
+  getTokenSuppliesMap = (
+    args: GetTokenSuppliesMapArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getBalanceUpdates = (args: GetBalanceUpdatesArgs, headers?: object): Promise<GetBalanceUpdatesReturn> => {
-    return this.fetch(this.url('GetBalanceUpdates'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>_data.page,
-          balances: <Array<TokenBalance>>_data.balances
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getTransactionHistory = (args: GetTransactionHistoryArgs, headers?: object): Promise<GetTransactionHistoryReturn> => {
-    return this.fetch(this.url('GetTransactionHistory'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>_data.page,
-          transactions: <Array<Transaction>>_data.transactions
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  syncBalance = (args: SyncBalanceArgs, headers?: object): Promise<SyncBalanceReturn> => {
-    return this.fetch(this.url('SyncBalance'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {}
-      })
-    })
+  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 {}
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  fetchTransactionReceipt = (args: FetchTransactionReceiptArgs, headers?: object): Promise<FetchTransactionReceiptReturn> => {
-    return this.fetch(this.url('FetchTransactionReceipt'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          receipt: <TransactionReceipt>_data.receipt
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getOrderbookOrders = (args: GetOrderbookOrdersArgs, headers?: object): Promise<GetOrderbookOrdersReturn> => {
-    return this.fetch(this.url('GetOrderbookOrders'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>_data.page,
-          orders: <Array<OrderbookOrder>>_data.orders
-        }
-      })
-    })
+  getOrderbookOrders = (
+    args: GetOrderbookOrdersArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getTopOrders = (args: GetTopOrdersArgs, headers?: object): Promise<GetTopOrdersReturn> => {
-    return this.fetch(this.url('GetTopOrders'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          orders: <Array<OrderbookOrder>>_data.orders
-        }
-      })
-    })
+  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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
   fetchTransactionReceiptWithFilter = (
     args: FetchTransactionReceiptWithFilterArgs,
-    headers?: object
+    headers?: object,
+    signal?: AbortSignal
   ): Promise<FetchTransactionReceiptWithFilterReturn> => {
-    return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          receipt: <TransactionReceipt>_data.receipt
-        }
-      })
-    })
+    return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            receipt: <TransactionReceipt>_data.receipt
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getAllWebhookListeners = (args: GetAllWebhookListenersArgs, headers?: object): Promise<GetAllWebhookListenersReturn> => {
-    return this.fetch(this.url('GetAllWebhookListeners'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          listeners: <Array<WebhookListener>>_data.listeners
-        }
-      })
-    })
+  getAllWebhookListeners = (
+    args: GetAllWebhookListenersArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  getWebhookListener = (args: GetWebhookListenerArgs, headers?: object): Promise<GetWebhookListenerReturn> => {
-    return this.fetch(this.url('GetWebhookListener'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          listener: <WebhookListener>_data.listener
-        }
-      })
-    })
+  getWebhookListener = (
+    args: GetWebhookListenerArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  addWebhookListener = (args: AddWebhookListenerArgs, headers?: object): Promise<AddWebhookListenerReturn> => {
-    return this.fetch(this.url('AddWebhookListener'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>_data.status,
-          listener: <WebhookListener>_data.listener
-        }
-      })
-    })
+  addWebhookListener = (
+    args: AddWebhookListenerArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  updateWebhookListener = (args: UpdateWebhookListenerArgs, headers?: object): Promise<UpdateWebhookListenerReturn> => {
-    return this.fetch(this.url('UpdateWebhookListener'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>_data.status
-        }
-      })
-    })
+  updateWebhookListener = (
+    args: UpdateWebhookListenerArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
 
-  removeWebhookListener = (args: RemoveWebhookListenerArgs, headers?: object): Promise<RemoveWebhookListenerReturn> => {
-    return this.fetch(this.url('RemoveWebhookListener'), createHTTPRequest(args, headers)).then(res => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>_data.status
+  removeWebhookListener = (
+    args: RemoveWebhookListenerArgs,
+    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
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  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()
   }
 }
 
-export interface WebRPCError extends Error {
-  code: string
-  msg: string
-  status: number
+const sseResponse = async (res: Response, options: WebrpcStreamOptions<any>, retryFetch: () => Promise<void>) => {
+  const { onMessage, onOpen, onClose, onError } = options
+
+  if (!res.ok) {
+    try {
+      await buildResponse(res)
+    } catch (error) {
+      // @ts-ignore
+      onError(error, retryFetch)
+    }
+    return
+  }
+
+  if (!res.body) {
+    onError(
+      WebrpcBadResponseError.new({
+        status: res.status,
+        cause: 'Invalid response, missing body'
+      }),
+      retryFetch
+    )
+    return
+  }
+
+  onOpen && onOpen()
+
+  const reader = res.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  let lastReadTime = Date.now()
+  const timeout = (10 + 1) * 1000
+  let intervalId: any
+
+  try {
+    intervalId = setInterval(() => {
+      if (Date.now() - lastReadTime > timeout) {
+        throw WebrpcStreamLostError.new({ cause: 'Stream timed out' })
+      }
+    }, timeout)
+
+    while (true) {
+      let value
+      let done
+      try {
+        ;({ value, done } = await reader.read())
+        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({
+              message: 'AbortError',
+              cause: `AbortError: ${message}`
+            }),
+            () => {
+              throw new Error('Abort signal cannot be used to reconnect')
+            }
+          )
+        } else {
+          onError(
+            WebrpcStreamLostError.new({
+              cause: `reader.read(): ${message}`
+            }),
+            retryFetch
+          )
+        }
+        return
+      }
+
+      let lines = buffer.split('\n')
+      for (let i = 0; i < lines.length - 1; i++) {
+        if (lines[i].length == 0) {
+          continue
+        }
+        let data: any
+        try {
+          data = JSON.parse(lines[i])
+          if (data.hasOwnProperty('webrpcError')) {
+            const error = data.webrpcError
+            const code: number = typeof error.code === 'number' ? error.code : 0
+            onError((webrpcErrorByCode[code] || WebrpcError).new(error), retryFetch)
+            return
+          }
+        } catch (error) {
+          if (error instanceof Error && error.message === 'Abort signal cannot be used to reconnect') {
+            throw error
+          }
+          onError(
+            WebrpcBadResponseError.new({
+              status: res.status,
+              // @ts-ignore
+              cause: `JSON.parse(): ${error.message}`
+            }),
+            retryFetch
+          )
+        }
+        onMessage(data)
+      }
+
+      if (!done) {
+        buffer = lines[lines.length - 1]
+        continue
+      }
+
+      onClose && onClose()
+      return
+    }
+  } catch (error) {
+    // @ts-ignore
+    if (error instanceof WebrpcStreamLostError) {
+      onError(error, retryFetch)
+    } else {
+      throw error
+    }
+  } finally {
+    clearInterval(intervalId)
+  }
 }
 
-const createHTTPRequest = (body: object = {}, headers: object = {}): object => {
+const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
   return {
     method: 'POST',
     headers: { ...headers, 'Content-Type': 'application/json' },
-    body: JSON.stringify(body || {})
+    body: JSON.stringify(body || {}),
+    signal
   }
 }
 
@@ -820,14 +1169,433 @@ const buildResponse = (res: Response): Promise<any> => {
     let data
     try {
       data = JSON.parse(text)
-    } catch (err) {
-      throw { code: 'unknown', msg: `expecting JSON, got: ${text}`, status: res.status } as WebRPCError
+    } catch (error) {
+      let message = ''
+      if (error instanceof Error) {
+        message = error.message
+      }
+      throw WebrpcBadResponseError.new({
+        status: res.status,
+        cause: `JSON.parse(): ${message}: response text: ${text}`
+      })
     }
     if (!res.ok) {
-      throw data // webrpc error response
+      const code: number = typeof data.code === 'number' ? data.code : 0
+      throw (webrpcErrorByCode[code] || WebrpcError).new(data)
     }
     return data
   })
 }
 
+//
+// Errors
+//
+
+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
+    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)
+  }
+}
+
+// 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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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)
+    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 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)
+    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)
+    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 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 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 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 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 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 TimeoutError extends WebrpcError {
+  constructor(
+    name: string = 'Timeout',
+    code: number = 2000,
+    message: string = 'Request timed out',
+    status: number = 0,
+    cause?: string
+  ) {
+    super(name, code, message, status, cause)
+    Object.setPrototypeOf(this, TimeoutError.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 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 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 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 ProjectNotFoundError extends WebrpcError {
+  constructor(
+    name: string = 'ProjectNotFound',
+    code: number = 3002,
+    message: string = 'Project not found',
+    status: number = 0,
+    cause?: string
+  ) {
+    super(name, code, message, status, cause)
+    Object.setPrototypeOf(this, ProjectNotFoundError.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 enum errors {
+  WebrpcEndpoint = 'WebrpcEndpoint',
+  WebrpcRequestFailed = 'WebrpcRequestFailed',
+  WebrpcBadRoute = 'WebrpcBadRoute',
+  WebrpcBadMethod = 'WebrpcBadMethod',
+  WebrpcBadRequest = 'WebrpcBadRequest',
+  WebrpcBadResponse = 'WebrpcBadResponse',
+  WebrpcServerPanic = 'WebrpcServerPanic',
+  WebrpcInternalError = 'WebrpcInternalError',
+  WebrpcClientDisconnected = 'WebrpcClientDisconnected',
+  WebrpcStreamLost = 'WebrpcStreamLost',
+  WebrpcStreamFinished = 'WebrpcStreamFinished',
+  Unauthorized = 'Unauthorized',
+  PermissionDenied = 'PermissionDenied',
+  SessionExpired = 'SessionExpired',
+  MethodNotFound = 'MethodNotFound',
+  RequestConflict = 'RequestConflict',
+  Aborted = 'Aborted',
+  Timeout = 'Timeout',
+  InvalidArgument = 'InvalidArgument',
+  Unavailable = 'Unavailable',
+  QueryFailed = 'QueryFailed',
+  NotFound = 'NotFound',
+  ProjectNotFound = 'ProjectNotFound',
+  MetadataCallFailed = 'MetadataCallFailed'
+}
+
+const webrpcErrorByCode: { [code: number]: any } = {
+  [0]: WebrpcEndpointError,
+  [-1]: WebrpcRequestFailedError,
+  [-2]: WebrpcBadRouteError,
+  [-3]: WebrpcBadMethodError,
+  [-4]: WebrpcBadRequestError,
+  [-5]: WebrpcBadResponseError,
+  [-6]: WebrpcServerPanicError,
+  [-7]: WebrpcInternalErrorError,
+  [-8]: WebrpcClientDisconnectedError,
+  [-9]: WebrpcStreamLostError,
+  [-10]: WebrpcStreamFinishedError,
+  [1000]: UnauthorizedError,
+  [1001]: PermissionDeniedError,
+  [1002]: SessionExpiredError,
+  [1003]: MethodNotFoundError,
+  [1004]: RequestConflictError,
+  [1005]: AbortedError,
+  [2000]: TimeoutError,
+  [2001]: InvalidArgumentError,
+  [2002]: UnavailableError,
+  [2003]: QueryFailedError,
+  [3000]: NotFoundError,
+  [3002]: ProjectNotFoundError,
+  [3003]: MetadataCallFailedError
+}
+
 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
+}