@0xsequence/indexer 2.1.8 → 2.2.0

package/dist/0xsequence-indexer.cjs.dev.js

@@ -20,19 +20,19 @@ function _extends() {
 // webrpc-gen -schema=indexer.ridl -target=typescript -client -out=./clients/indexer.gen.ts
 
 // WebRPC description and code-gen version
-const WebRPCVersion = 'v1';
+const WebRPCVersion$1 = 'v1';
 
 // Schema version of your RIDL schema
-const WebRPCSchemaVersion = 'v0.4.0';
+const WebRPCSchemaVersion$1 = 'v0.4.0';
 
 // Schema hash generated from your RIDL schema
-const WebRPCSchemaHash = 'cae735346d8e5c3dce48dce9f85116989b6beffd';
+const WebRPCSchemaHash$1 = 'cae735346d8e5c3dce48dce9f85116989b6beffd';
 
 //
 // Types
 //
 
-let ContractType = /*#__PURE__*/function (ContractType) {
+let ContractType$1 = /*#__PURE__*/function (ContractType) {
   ContractType["UNKNOWN"] = "UNKNOWN";
   ContractType["NATIVE"] = "NATIVE";
   ContractType["ERC20"] = "ERC20";
@@ -45,48 +45,48 @@ let ContractType = /*#__PURE__*/function (ContractType) {
   ContractType["SEQ_MARKETPLACE"] = "SEQ_MARKETPLACE";
   return ContractType;
 }({});
-let EventLogType = /*#__PURE__*/function (EventLogType) {
+let EventLogType$1 = /*#__PURE__*/function (EventLogType) {
   EventLogType["UNKNOWN"] = "UNKNOWN";
   EventLogType["BLOCK_ADDED"] = "BLOCK_ADDED";
   EventLogType["BLOCK_REMOVED"] = "BLOCK_REMOVED";
   return EventLogType;
 }({});
-let EventLogDataType = /*#__PURE__*/function (EventLogDataType) {
+let EventLogDataType$1 = /*#__PURE__*/function (EventLogDataType) {
   EventLogDataType["EVENT"] = "EVENT";
   EventLogDataType["TOKEN_TRANSFER"] = "TOKEN_TRANSFER";
   EventLogDataType["NATIVE_TOKEN_TRANSFER"] = "NATIVE_TOKEN_TRANSFER";
   EventLogDataType["SEQUENCE_TXN"] = "SEQUENCE_TXN";
   return EventLogDataType;
 }({});
-let OrderStatus = /*#__PURE__*/function (OrderStatus) {
+let OrderStatus$1 = /*#__PURE__*/function (OrderStatus) {
   OrderStatus["OPEN"] = "OPEN";
   OrderStatus["CLOSED"] = "CLOSED";
   OrderStatus["CANCELLED"] = "CANCELLED";
   return OrderStatus;
 }({});
-let TxnTransferType = /*#__PURE__*/function (TxnTransferType) {
+let TxnTransferType$1 = /*#__PURE__*/function (TxnTransferType) {
   TxnTransferType["UNKNOWN"] = "UNKNOWN";
   TxnTransferType["SEND"] = "SEND";
   TxnTransferType["RECEIVE"] = "RECEIVE";
   return TxnTransferType;
 }({});
-let TransactionStatus = /*#__PURE__*/function (TransactionStatus) {
+let TransactionStatus$1 = /*#__PURE__*/function (TransactionStatus) {
   TransactionStatus["FAILED"] = "FAILED";
   TransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
   return TransactionStatus;
 }({});
-let TransactionType = /*#__PURE__*/function (TransactionType) {
+let TransactionType$1 = /*#__PURE__*/function (TransactionType) {
   TransactionType["LegacyTxnType"] = "LegacyTxnType";
   TransactionType["AccessListTxnType"] = "AccessListTxnType";
   TransactionType["DynamicFeeTxnType"] = "DynamicFeeTxnType";
   return TransactionType;
 }({});
-let SortOrder = /*#__PURE__*/function (SortOrder) {
+let SortOrder$1 = /*#__PURE__*/function (SortOrder) {
   SortOrder["DESC"] = "DESC";
   SortOrder["ASC"] = "ASC";
   return SortOrder;
 }({});
-let ContractVerificationStatus = /*#__PURE__*/function (ContractVerificationStatus) {
+let ContractVerificationStatus$1 = /*#__PURE__*/function (ContractVerificationStatus) {
   ContractVerificationStatus["VERIFIED"] = "VERIFIED";
   ContractVerificationStatus["UNVERIFIED"] = "UNVERIFIED";
   ContractVerificationStatus["ALL"] = "ALL";
@@ -101,142 +101,142 @@ class Indexer {
     this.fetch = void 0;
     this.path = '/rpc/Indexer/';
     this.ping = (headers, signal) => {
-      return this.fetch(this.url('Ping'), createHTTPRequest({}, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('Ping'), createHTTPRequest$1({}, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.version = (headers, signal) => {
-      return this.fetch(this.url('Version'), createHTTPRequest({}, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('Version'), createHTTPRequest$1({}, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             version: _data.version
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.runtimeStatus = (headers, signal) => {
-      return this.fetch(this.url('RuntimeStatus'), createHTTPRequest({}, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('RuntimeStatus'), createHTTPRequest$1({}, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getChainID = (headers, signal) => {
-      return this.fetch(this.url('GetChainID'), createHTTPRequest({}, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetChainID'), createHTTPRequest$1({}, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             chainID: _data.chainID
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getEtherBalance = (args, headers, signal) => {
-      return this.fetch(this.url('GetEtherBalance'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetEtherBalance'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             balance: _data.balance
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getNativeTokenBalance = (args, headers, signal) => {
-      return this.fetch(this.url('GetNativeTokenBalance'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetNativeTokenBalance'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             balance: _data.balance
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenBalancesSummary = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenBalancesSummary'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenBalancesSummary'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             balances: _data.balances
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenBalancesDetails = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenBalancesDetails'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenBalancesDetails'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             balances: _data.balances
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenBalancesByContract = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenBalancesByContract'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenBalancesByContract'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             balances: _data.balances
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenBalances = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenBalances'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenBalances'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             balances: _data.balances
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenSupplies = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenSupplies'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenSupplies'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             contractType: _data.contractType,
@@ -244,223 +244,223 @@ class Indexer {
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTokenSuppliesMap = (args, headers, signal) => {
-      return this.fetch(this.url('GetTokenSuppliesMap'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTokenSuppliesMap'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             supplies: _data.supplies
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getBalanceUpdates = (args, headers, signal) => {
-      return this.fetch(this.url('GetBalanceUpdates'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetBalanceUpdates'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             balances: _data.balances
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTransactionHistory = (args, headers, signal) => {
-      return this.fetch(this.url('GetTransactionHistory'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTransactionHistory'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             transactions: _data.transactions
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.syncBalance = (args, headers, signal) => {
-      return this.fetch(this.url('SyncBalance'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('SyncBalance'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {};
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.fetchTransactionReceipt = (args, headers, signal) => {
-      return this.fetch(this.url('FetchTransactionReceipt'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('FetchTransactionReceipt'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             receipt: _data.receipt
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getOrderbookOrders = (args, headers, signal) => {
-      return this.fetch(this.url('GetOrderbookOrders'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetOrderbookOrders'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             page: _data.page,
             orders: _data.orders
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getTopOrders = (args, headers, signal) => {
-      return this.fetch(this.url('GetTopOrders'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetTopOrders'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             orders: _data.orders
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.fetchTransactionReceiptWithFilter = (args, headers, signal) => {
-      return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('FetchTransactionReceiptWithFilter'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             receipt: _data.receipt
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getAllWebhookListeners = (args, headers, signal) => {
-      return this.fetch(this.url('GetAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetAllWebhookListeners'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             listeners: _data.listeners
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.getWebhookListener = (args, headers, signal) => {
-      return this.fetch(this.url('GetWebhookListener'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('GetWebhookListener'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             listener: _data.listener
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.addWebhookListener = (args, headers, signal) => {
-      return this.fetch(this.url('AddWebhookListener'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('AddWebhookListener'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status,
             listener: _data.listener
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.updateWebhookListener = (args, headers, signal) => {
-      return this.fetch(this.url('UpdateWebhookListener'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('UpdateWebhookListener'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.removeWebhookListener = (args, headers, signal) => {
-      return this.fetch(this.url('RemoveWebhookListener'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('RemoveWebhookListener'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.toggleWebhookListener = (args, headers, signal) => {
-      return this.fetch(this.url('ToggleWebhookListener'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('ToggleWebhookListener'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             webhookListener: _data.webhookListener
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.pauseAllWebhookListeners = (args, headers, signal) => {
-      return this.fetch(this.url('PauseAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('PauseAllWebhookListeners'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.resumeAllWebhookListeners = (args, headers, signal) => {
-      return this.fetch(this.url('ResumeAllWebhookListeners'), createHTTPRequest(args, headers, signal)).then(res => {
-        return buildResponse(res).then(_data => {
+      return this.fetch(this.url('ResumeAllWebhookListeners'), createHTTPRequest$1(args, headers, signal)).then(res => {
+        return buildResponse$1(res).then(_data => {
           return {
             status: _data.status
           };
         });
       }, error => {
-        throw WebrpcRequestFailedError.new({
+        throw WebrpcRequestFailedError$1.new({
           cause: `fetch(): ${error.message || ''}`
         });
       });
     };
     this.subscribeReceipts = (args, options) => {
-      const _fetch = () => this.fetch(this.url('SubscribeReceipts'), createHTTPRequest(args, options.headers, options.signal)).then(async function (res) {
+      const _fetch = () => this.fetch(this.url('SubscribeReceipts'), createHTTPRequest$1(args, options.headers, options.signal)).then(async function (res) {
         await sseResponse(res, options, _fetch);
       }, error => {
         options.onError(error, _fetch);
@@ -468,7 +468,7 @@ class Indexer {
       return _fetch();
     };
     this.subscribeEvents = (args, options) => {
-      const _fetch = () => this.fetch(this.url('SubscribeEvents'), createHTTPRequest(args, options.headers, options.signal)).then(async function (res) {
+      const _fetch = () => this.fetch(this.url('SubscribeEvents'), createHTTPRequest$1(args, options.headers, options.signal)).then(async function (res) {
         await sseResponse(res, options, _fetch);
       }, error => {
         options.onError(error, _fetch);
@@ -476,7 +476,7 @@ class Indexer {
       return _fetch();
     };
     this.subscribeBalanceUpdates = (args, options) => {
-      const _fetch = () => this.fetch(this.url('SubscribeBalanceUpdates'), createHTTPRequest(args, options.headers, options.signal)).then(async function (res) {
+      const _fetch = () => this.fetch(this.url('SubscribeBalanceUpdates'), createHTTPRequest$1(args, options.headers, options.signal)).then(async function (res) {
         await sseResponse(res, options, _fetch);
       }, error => {
         options.onError(error, _fetch);
@@ -499,7 +499,7 @@ const sseResponse = async (res, options, retryFetch) => {
   } = options;
   if (!res.ok) {
     try {
-      await buildResponse(res);
+      await buildResponse$1(res);
     } catch (error) {
       // @ts-ignore
       onError(error, retryFetch);
@@ -507,7 +507,7 @@ const sseResponse = async (res, options, retryFetch) => {
     return;
   }
   if (!res.body) {
-    onError(WebrpcBadResponseError.new({
+    onError(WebrpcBadResponseError$1.new({
       status: res.status,
       cause: 'Invalid response, missing body'
     }), retryFetch);
@@ -547,14 +547,14 @@ const sseResponse = async (res, options, retryFetch) => {
         message = error.message;
       }
       if (error instanceof DOMException && error.name === 'AbortError') {
-        onError(WebrpcRequestFailedError.new({
+        onError(WebrpcRequestFailedError$1.new({
           message: 'AbortError',
           cause: `AbortError: ${message}`
         }), () => {
           throw new Error('Abort signal cannot be used to reconnect');
         });
       } else {
-        onError(WebrpcStreamLostError.new({
+        onError(WebrpcStreamLostError$1.new({
           cause: `reader.read(): ${message}`
         }), retryFetch);
       }
@@ -571,14 +571,14 @@ const sseResponse = async (res, options, retryFetch) => {
         if (data.hasOwnProperty('webrpcError')) {
           const error = data.webrpcError;
           const code = typeof error.code === 'number' ? error.code : 0;
-          onError((webrpcErrorByCode[code] || WebrpcError).new(error), retryFetch);
+          onError((webrpcErrorByCode$1[code] || WebrpcError$1).new(error), retryFetch);
           return;
         }
       } catch (error) {
         if (error instanceof Error && error.message === 'Abort signal cannot be used to reconnect') {
           throw error;
         }
-        onError(WebrpcBadResponseError.new({
+        onError(WebrpcBadResponseError$1.new({
           status: res.status,
           // @ts-ignore
           cause: `JSON.parse(): ${error.message}`
@@ -594,7 +594,7 @@ const sseResponse = async (res, options, retryFetch) => {
     return;
   }
 };
-const createHTTPRequest = (body = {}, headers = {}, signal = null) => {
+const createHTTPRequest$1 = (body = {}, headers = {}, signal = null) => {
   return {
     method: 'POST',
     headers: _extends({}, headers, {
@@ -604,7 +604,7 @@ const createHTTPRequest = (body = {}, headers = {}, signal = null) => {
     signal
   };
 };
-const buildResponse = res => {
+const buildResponse$1 = res => {
   return res.text().then(text => {
     let data;
     try {
@@ -614,14 +614,14 @@ const buildResponse = res => {
       if (error instanceof Error) {
         message = error.message;
       }
-      throw WebrpcBadResponseError.new({
+      throw WebrpcBadResponseError$1.new({
         status: res.status,
         cause: `JSON.parse(): ${message}: response text: ${text}`
       });
     }
     if (!res.ok) {
       const code = typeof data.code === 'number' ? data.code : 0;
-      throw (webrpcErrorByCode[code] || WebrpcError).new(data);
+      throw (webrpcErrorByCode$1[code] || WebrpcError$1).new(data);
     }
     return data;
   });
@@ -631,7 +631,7 @@ const buildResponse = res => {
 // Errors
 //
 
-class WebrpcError extends Error {
+class WebrpcError$1 extends Error {
   constructor(name, code, message, status, cause) {
     super(message);
     this.name = void 0;
@@ -647,7 +647,7 @@ class WebrpcError extends Error {
     this.msg = this.message;
     this.status = typeof status === 'number' ? status : 0;
     this.cause = cause;
-    Object.setPrototypeOf(this, WebrpcError.prototype);
+    Object.setPrototypeOf(this, WebrpcError$1.prototype);
   }
   static new(payload) {
     return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause);
@@ -656,160 +656,160 @@ class WebrpcError extends Error {
 
 // Webrpc errors
 
-class WebrpcEndpointError extends WebrpcError {
+class WebrpcEndpointError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcEndpoint', code = 0, message = 'endpoint error', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcEndpointError.prototype);
+    Object.setPrototypeOf(this, WebrpcEndpointError$1.prototype);
   }
 }
-class WebrpcRequestFailedError extends WebrpcError {
+class WebrpcRequestFailedError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcRequestFailed', code = -1, message = 'request failed', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype);
+    Object.setPrototypeOf(this, WebrpcRequestFailedError$1.prototype);
   }
 }
-class WebrpcBadRouteError extends WebrpcError {
+class WebrpcBadRouteError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcBadRoute', code = -2, message = 'bad route', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcBadRouteError.prototype);
+    Object.setPrototypeOf(this, WebrpcBadRouteError$1.prototype);
   }
 }
-class WebrpcBadMethodError extends WebrpcError {
+class WebrpcBadMethodError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcBadMethod', code = -3, message = 'bad method', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcBadMethodError.prototype);
+    Object.setPrototypeOf(this, WebrpcBadMethodError$1.prototype);
   }
 }
-class WebrpcBadRequestError extends WebrpcError {
+class WebrpcBadRequestError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcBadRequest', code = -4, message = 'bad request', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcBadRequestError.prototype);
+    Object.setPrototypeOf(this, WebrpcBadRequestError$1.prototype);
   }
 }
-class WebrpcBadResponseError extends WebrpcError {
+class WebrpcBadResponseError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcBadResponse', code = -5, message = 'bad response', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcBadResponseError.prototype);
+    Object.setPrototypeOf(this, WebrpcBadResponseError$1.prototype);
   }
 }
-class WebrpcServerPanicError extends WebrpcError {
+class WebrpcServerPanicError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcServerPanic', code = -6, message = 'server panic', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcServerPanicError.prototype);
+    Object.setPrototypeOf(this, WebrpcServerPanicError$1.prototype);
   }
 }
-class WebrpcInternalErrorError extends WebrpcError {
+class WebrpcInternalErrorError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcInternalError', code = -7, message = 'internal error', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype);
+    Object.setPrototypeOf(this, WebrpcInternalErrorError$1.prototype);
   }
 }
-class WebrpcClientDisconnectedError extends WebrpcError {
+class WebrpcClientDisconnectedError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcClientDisconnected', code = -8, message = 'client disconnected', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype);
+    Object.setPrototypeOf(this, WebrpcClientDisconnectedError$1.prototype);
   }
 }
-class WebrpcStreamLostError extends WebrpcError {
+class WebrpcStreamLostError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcStreamLost', code = -9, message = 'stream lost', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcStreamLostError.prototype);
+    Object.setPrototypeOf(this, WebrpcStreamLostError$1.prototype);
   }
 }
-class WebrpcStreamFinishedError extends WebrpcError {
+class WebrpcStreamFinishedError$1 extends WebrpcError$1 {
   constructor(name = 'WebrpcStreamFinished', code = -10, message = 'stream finished', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype);
+    Object.setPrototypeOf(this, WebrpcStreamFinishedError$1.prototype);
   }
 }
 
 // Schema errors
 
-class UnauthorizedError extends WebrpcError {
+class UnauthorizedError$1 extends WebrpcError$1 {
   constructor(name = 'Unauthorized', code = 1000, message = 'Unauthorized access', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+    Object.setPrototypeOf(this, UnauthorizedError$1.prototype);
   }
 }
-class PermissionDeniedError extends WebrpcError {
+class PermissionDeniedError$1 extends WebrpcError$1 {
   constructor(name = 'PermissionDenied', code = 1001, message = 'Permission denied', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, PermissionDeniedError.prototype);
+    Object.setPrototypeOf(this, PermissionDeniedError$1.prototype);
   }
 }
-class SessionExpiredError extends WebrpcError {
+class SessionExpiredError$1 extends WebrpcError$1 {
   constructor(name = 'SessionExpired', code = 1002, message = 'Session expired', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, SessionExpiredError.prototype);
+    Object.setPrototypeOf(this, SessionExpiredError$1.prototype);
   }
 }
-class MethodNotFoundError extends WebrpcError {
+class MethodNotFoundError$1 extends WebrpcError$1 {
   constructor(name = 'MethodNotFound', code = 1003, message = 'Method not found', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, MethodNotFoundError.prototype);
+    Object.setPrototypeOf(this, MethodNotFoundError$1.prototype);
   }
 }
-class RequestConflictError extends WebrpcError {
+class RequestConflictError$1 extends WebrpcError$1 {
   constructor(name = 'RequestConflict', code = 1004, message = 'Conflict with target resource', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, RequestConflictError.prototype);
+    Object.setPrototypeOf(this, RequestConflictError$1.prototype);
   }
 }
-class AbortedError extends WebrpcError {
+class AbortedError$1 extends WebrpcError$1 {
   constructor(name = 'Aborted', code = 1005, message = 'Request aborted', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, AbortedError.prototype);
+    Object.setPrototypeOf(this, AbortedError$1.prototype);
   }
 }
-class TimeoutError extends WebrpcError {
+class TimeoutError$1 extends WebrpcError$1 {
   constructor(name = 'Timeout', code = 2000, message = 'Request timed out', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, TimeoutError.prototype);
+    Object.setPrototypeOf(this, TimeoutError$1.prototype);
   }
 }
-class InvalidArgumentError extends WebrpcError {
+class InvalidArgumentError$1 extends WebrpcError$1 {
   constructor(name = 'InvalidArgument', code = 2001, message = 'Invalid argument', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, InvalidArgumentError.prototype);
+    Object.setPrototypeOf(this, InvalidArgumentError$1.prototype);
   }
 }
-class UnavailableError extends WebrpcError {
+class UnavailableError$1 extends WebrpcError$1 {
   constructor(name = 'Unavailable', code = 2002, message = 'Unavailable resource', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, UnavailableError.prototype);
+    Object.setPrototypeOf(this, UnavailableError$1.prototype);
   }
 }
-class QueryFailedError extends WebrpcError {
+class QueryFailedError$1 extends WebrpcError$1 {
   constructor(name = 'QueryFailed', code = 2003, message = 'Query failed', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, QueryFailedError.prototype);
+    Object.setPrototypeOf(this, QueryFailedError$1.prototype);
   }
 }
-class ResourceExhaustedError extends WebrpcError {
+class ResourceExhaustedError$1 extends WebrpcError$1 {
   constructor(name = 'ResourceExhausted', code = 2004, message = 'Resource exhausted', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, ResourceExhaustedError.prototype);
+    Object.setPrototypeOf(this, ResourceExhaustedError$1.prototype);
   }
 }
-class NotFoundError extends WebrpcError {
+class NotFoundError$1 extends WebrpcError$1 {
   constructor(name = 'NotFound', code = 3000, message = 'Resource not found', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, NotFoundError.prototype);
+    Object.setPrototypeOf(this, NotFoundError$1.prototype);
   }
 }
-class ProjectNotFoundError extends WebrpcError {
+class ProjectNotFoundError$1 extends WebrpcError$1 {
   constructor(name = 'ProjectNotFound', code = 3002, message = 'Project not found', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, ProjectNotFoundError.prototype);
+    Object.setPrototypeOf(this, ProjectNotFoundError$1.prototype);
   }
 }
-class MetadataCallFailedError extends WebrpcError {
+class MetadataCallFailedError$1 extends WebrpcError$1 {
   constructor(name = 'MetadataCallFailed', code = 3003, message = 'Metadata service call failed', status = 0, cause) {
     super(name, code, message, status, cause);
-    Object.setPrototypeOf(this, MetadataCallFailedError.prototype);
+    Object.setPrototypeOf(this, MetadataCallFailedError$1.prototype);
   }
 }
-let errors = /*#__PURE__*/function (errors) {
+let errors$1 = /*#__PURE__*/function (errors) {
   errors["WebrpcEndpoint"] = "WebrpcEndpoint";
   errors["WebrpcRequestFailed"] = "WebrpcRequestFailed";
   errors["WebrpcBadRoute"] = "WebrpcBadRoute";
@@ -837,35 +837,743 @@ let errors = /*#__PURE__*/function (errors) {
   errors["MetadataCallFailed"] = "MetadataCallFailed";
   return errors;
 }({});
-const webrpcErrorByCode = {
-  [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,
-  [2004]: ResourceExhaustedError,
-  [3000]: NotFoundError,
-  [3002]: ProjectNotFoundError,
-  [3003]: MetadataCallFailedError
+const webrpcErrorByCode$1 = {
+  [0]: WebrpcEndpointError$1,
+  [-1]: WebrpcRequestFailedError$1,
+  [-2]: WebrpcBadRouteError$1,
+  [-3]: WebrpcBadMethodError$1,
+  [-4]: WebrpcBadRequestError$1,
+  [-5]: WebrpcBadResponseError$1,
+  [-6]: WebrpcServerPanicError$1,
+  [-7]: WebrpcInternalErrorError$1,
+  [-8]: WebrpcClientDisconnectedError$1,
+  [-9]: WebrpcStreamLostError$1,
+  [-10]: WebrpcStreamFinishedError$1,
+  [1000]: UnauthorizedError$1,
+  [1001]: PermissionDeniedError$1,
+  [1002]: SessionExpiredError$1,
+  [1003]: MethodNotFoundError$1,
+  [1004]: RequestConflictError$1,
+  [1005]: AbortedError$1,
+  [2000]: TimeoutError$1,
+  [2001]: InvalidArgumentError$1,
+  [2002]: UnavailableError$1,
+  [2003]: QueryFailedError$1,
+  [2004]: ResourceExhaustedError$1,
+  [3000]: NotFoundError$1,
+  [3002]: ProjectNotFoundError$1,
+  [3003]: MetadataCallFailedError$1
 };
 
-class SequenceIndexer extends Indexer {
+/* eslint-disable */
+// sequence-indexer v0.4.0 71cd081c5ca2372bf92a897ae1aa4ebf93ffd0fc
+// --
+// Code generated by webrpc-gen@v0.21.1 with typescript generator. DO NOT EDIT.
+//
+// webrpc-gen -schema=indexer.ridl -service=IndexerGateway -target=typescript -client -out=./clients/indexergw/indexer.gen.ts
+
+const WebrpcHeader = "Webrpc";
+const WebrpcHeaderValue = "webrpc@v0.21.1;gen-typescript@v0.15.1;sequence-indexer@v0.4.0";
+
+// WebRPC description and code-gen version
+const WebRPCVersion = "v1";
+
+// Schema version of your RIDL schema
+const WebRPCSchemaVersion = "v0.4.0";
+
+// Schema hash generated from your RIDL schema
+const WebRPCSchemaHash = "71cd081c5ca2372bf92a897ae1aa4ebf93ffd0fc";
+function VersionFromHeader(headers) {
+  const headerValue = headers.get(WebrpcHeader);
+  if (!headerValue) {
+    return {
+      webrpcGenVersion: "",
+      codeGenName: "",
+      codeGenVersion: "",
+      schemaName: "",
+      schemaVersion: ""
+    };
+  }
+  return parseWebrpcGenVersions(headerValue);
+}
+function parseWebrpcGenVersions(header) {
+  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,
+    codeGenName,
+    codeGenVersion,
+    schemaName,
+    schemaVersion
+  };
+}
+
+//
+// Types
+//
+
+let ContractType = /*#__PURE__*/function (ContractType) {
+  ContractType["UNKNOWN"] = "UNKNOWN";
+  ContractType["NATIVE"] = "NATIVE";
+  ContractType["ERC20"] = "ERC20";
+  ContractType["ERC721"] = "ERC721";
+  ContractType["ERC1155"] = "ERC1155";
+  ContractType["SEQUENCE_WALLET"] = "SEQUENCE_WALLET";
+  ContractType["ERC20_BRIDGE"] = "ERC20_BRIDGE";
+  ContractType["ERC721_BRIDGE"] = "ERC721_BRIDGE";
+  ContractType["ERC1155_BRIDGE"] = "ERC1155_BRIDGE";
+  ContractType["SEQ_MARKETPLACE"] = "SEQ_MARKETPLACE";
+  return ContractType;
+}({});
+let EventLogType = /*#__PURE__*/function (EventLogType) {
+  EventLogType["UNKNOWN"] = "UNKNOWN";
+  EventLogType["BLOCK_ADDED"] = "BLOCK_ADDED";
+  EventLogType["BLOCK_REMOVED"] = "BLOCK_REMOVED";
+  return EventLogType;
+}({});
+let EventLogDataType = /*#__PURE__*/function (EventLogDataType) {
+  EventLogDataType["EVENT"] = "EVENT";
+  EventLogDataType["TOKEN_TRANSFER"] = "TOKEN_TRANSFER";
+  EventLogDataType["NATIVE_TOKEN_TRANSFER"] = "NATIVE_TOKEN_TRANSFER";
+  EventLogDataType["SEQUENCE_TXN"] = "SEQUENCE_TXN";
+  return EventLogDataType;
+}({});
+let OrderStatus = /*#__PURE__*/function (OrderStatus) {
+  OrderStatus["OPEN"] = "OPEN";
+  OrderStatus["CLOSED"] = "CLOSED";
+  OrderStatus["CANCELLED"] = "CANCELLED";
+  return OrderStatus;
+}({});
+let TxnTransferType = /*#__PURE__*/function (TxnTransferType) {
+  TxnTransferType["UNKNOWN"] = "UNKNOWN";
+  TxnTransferType["SEND"] = "SEND";
+  TxnTransferType["RECEIVE"] = "RECEIVE";
+  return TxnTransferType;
+}({});
+let TransactionStatus = /*#__PURE__*/function (TransactionStatus) {
+  TransactionStatus["FAILED"] = "FAILED";
+  TransactionStatus["SUCCESSFUL"] = "SUCCESSFUL";
+  return TransactionStatus;
+}({});
+let TransactionType = /*#__PURE__*/function (TransactionType) {
+  TransactionType["LegacyTxnType"] = "LegacyTxnType";
+  TransactionType["AccessListTxnType"] = "AccessListTxnType";
+  TransactionType["DynamicFeeTxnType"] = "DynamicFeeTxnType";
+  return TransactionType;
+}({});
+let SortOrder = /*#__PURE__*/function (SortOrder) {
+  SortOrder["DESC"] = "DESC";
+  SortOrder["ASC"] = "ASC";
+  return SortOrder;
+}({});
+let ContractVerificationStatus = /*#__PURE__*/function (ContractVerificationStatus) {
+  ContractVerificationStatus["VERIFIED"] = "VERIFIED";
+  ContractVerificationStatus["UNVERIFIED"] = "UNVERIFIED";
+  ContractVerificationStatus["ALL"] = "ALL";
+  return ContractVerificationStatus;
+}({});
+//
+// Client
+//
+class IndexerGateway {
+  constructor(hostname, fetch) {
+    this.hostname = void 0;
+    this.fetch = void 0;
+    this.path = '/rpc/IndexerGateway/';
+    this.getNativeTokenBalance = (args, headers, signal) => {
+      return this.fetch(this.url('GetNativeTokenBalance'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getTokenBalances = (args, headers, signal) => {
+      return this.fetch(this.url('GetTokenBalances'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: _data.page,
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getTokenBalancesSummary = (args, headers, signal) => {
+      return this.fetch(this.url('GetTokenBalancesSummary'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: _data.page,
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getTokenBalancesDetails = (args, headers, signal) => {
+      return this.fetch(this.url('GetTokenBalancesDetails'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: _data.page,
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getTokenBalancesByContract = (args, headers, signal) => {
+      return this.fetch(this.url('GetTokenBalancesByContract'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: _data.page,
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.getBalanceUpdates = (args, headers, signal) => {
+      return this.fetch(this.url('GetBalanceUpdates'), createHTTPRequest(args, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: _data.page,
+            balances: _data.balances
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.ping = (headers, signal) => {
+      return this.fetch(this.url('Ping'), createHTTPRequest({}, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: _data.status
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.version = (headers, signal) => {
+      return this.fetch(this.url('Version'), createHTTPRequest({}, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            version: _data.version
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.runtimeStatus = (headers, signal) => {
+      return this.fetch(this.url('RuntimeStatus'), createHTTPRequest({}, headers, signal)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: _data.status
+          };
+        });
+      }, error => {
+        throw WebrpcRequestFailedError.new({
+          cause: `fetch(): ${error.message || ''}`
+        });
+      });
+    };
+    this.hostname = hostname.replace(/\/*$/, '');
+    this.fetch = (input, init) => fetch(input, init);
+  }
+  url(name) {
+    return this.hostname + this.path + name;
+  }
+}
+const createHTTPRequest = (body = {}, headers = {}, signal = null) => {
+  const reqHeaders = _extends({}, headers, {
+    'Content-Type': 'application/json'
+  });
+  reqHeaders[WebrpcHeader] = WebrpcHeaderValue;
+  return {
+    method: 'POST',
+    headers: reqHeaders,
+    body: JSON.stringify(body || {}),
+    signal
+  };
+};
+const buildResponse = res => {
+  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}`
+      });
+    }
+    if (!res.ok) {
+      const code = typeof data.code === 'number' ? data.code : 0;
+      throw (webrpcErrorByCode[code] || WebrpcError).new(data);
+    }
+    return data;
+  });
+};
+
+//
+// Errors
+//
+
+class WebrpcError extends Error {
+  constructor(name, code, message, status, cause) {
+    super(message);
+    this.name = void 0;
+    this.code = void 0;
+    this.message = void 0;
+    this.status = void 0;
+    this.cause = void 0;
+    /** @deprecated Use message instead of msg. Deprecated in webrpc v0.11.0. */
+    this.msg = void 0;
+    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) {
+    return new this(payload.error, payload.code, payload.message || payload.msg, payload.status, payload.cause);
+  }
+}
+
+// Webrpc errors
+
+class WebrpcEndpointError extends WebrpcError {
+  constructor(name = 'WebrpcEndpoint', code = 0, message = 'endpoint error', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcEndpointError.prototype);
+  }
+}
+class WebrpcRequestFailedError extends WebrpcError {
+  constructor(name = 'WebrpcRequestFailed', code = -1, message = 'request failed', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcRequestFailedError.prototype);
+  }
+}
+class WebrpcBadRouteError extends WebrpcError {
+  constructor(name = 'WebrpcBadRoute', code = -2, message = 'bad route', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRouteError.prototype);
+  }
+}
+class WebrpcBadMethodError extends WebrpcError {
+  constructor(name = 'WebrpcBadMethod', code = -3, message = 'bad method', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadMethodError.prototype);
+  }
+}
+class WebrpcBadRequestError extends WebrpcError {
+  constructor(name = 'WebrpcBadRequest', code = -4, message = 'bad request', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadRequestError.prototype);
+  }
+}
+class WebrpcBadResponseError extends WebrpcError {
+  constructor(name = 'WebrpcBadResponse', code = -5, message = 'bad response', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcBadResponseError.prototype);
+  }
+}
+class WebrpcServerPanicError extends WebrpcError {
+  constructor(name = 'WebrpcServerPanic', code = -6, message = 'server panic', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcServerPanicError.prototype);
+  }
+}
+class WebrpcInternalErrorError extends WebrpcError {
+  constructor(name = 'WebrpcInternalError', code = -7, message = 'internal error', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcInternalErrorError.prototype);
+  }
+}
+class WebrpcClientDisconnectedError extends WebrpcError {
+  constructor(name = 'WebrpcClientDisconnected', code = -8, message = 'client disconnected', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcClientDisconnectedError.prototype);
+  }
+}
+class WebrpcStreamLostError extends WebrpcError {
+  constructor(name = 'WebrpcStreamLost', code = -9, message = 'stream lost', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamLostError.prototype);
+  }
+}
+class WebrpcStreamFinishedError extends WebrpcError {
+  constructor(name = 'WebrpcStreamFinished', code = -10, message = 'stream finished', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, WebrpcStreamFinishedError.prototype);
+  }
+}
+
+// Schema errors
+
+class UnauthorizedError extends WebrpcError {
+  constructor(name = 'Unauthorized', code = 1000, message = 'Unauthorized access', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UnauthorizedError.prototype);
+  }
+}
+class PermissionDeniedError extends WebrpcError {
+  constructor(name = 'PermissionDenied', code = 1001, message = 'Permission denied', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, PermissionDeniedError.prototype);
+  }
+}
+class SessionExpiredError extends WebrpcError {
+  constructor(name = 'SessionExpired', code = 1002, message = 'Session expired', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, SessionExpiredError.prototype);
+  }
+}
+class MethodNotFoundError extends WebrpcError {
+  constructor(name = 'MethodNotFound', code = 1003, message = 'Method not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, MethodNotFoundError.prototype);
+  }
+}
+class RequestConflictError extends WebrpcError {
+  constructor(name = 'RequestConflict', code = 1004, message = 'Conflict with target resource', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, RequestConflictError.prototype);
+  }
+}
+class AbortedError extends WebrpcError {
+  constructor(name = 'Aborted', code = 1005, message = 'Request aborted', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, AbortedError.prototype);
+  }
+}
+class GeoblockedError extends WebrpcError {
+  constructor(name = 'Geoblocked', code = 1006, message = 'Geoblocked region', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, GeoblockedError.prototype);
+  }
+}
+class RateLimitedError extends WebrpcError {
+  constructor(name = 'RateLimited', code = 1007, message = 'Rate-limited. Please slow down.', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, RateLimitedError.prototype);
+  }
+}
+class ProjectNotFoundError extends WebrpcError {
+  constructor(name = 'ProjectNotFound', code = 1100, message = 'Project not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ProjectNotFoundError.prototype);
+  }
+}
+class AccessKeyNotFoundError extends WebrpcError {
+  constructor(name = 'AccessKeyNotFound', code = 1101, message = 'Access key not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, AccessKeyNotFoundError.prototype);
+  }
+}
+class AccessKeyMismatchError extends WebrpcError {
+  constructor(name = 'AccessKeyMismatch', code = 1102, message = 'Access key mismatch', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, AccessKeyMismatchError.prototype);
+  }
+}
+class InvalidOriginError extends WebrpcError {
+  constructor(name = 'InvalidOrigin', code = 1103, message = 'Invalid origin for Access Key', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidOriginError.prototype);
+  }
+}
+class InvalidServiceError extends WebrpcError {
+  constructor(name = 'InvalidService', code = 1104, message = 'Service not enabled for Access key', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidServiceError.prototype);
+  }
+}
+class UnauthorizedUserError extends WebrpcError {
+  constructor(name = 'UnauthorizedUser', code = 1105, message = 'Unauthorized user', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UnauthorizedUserError.prototype);
+  }
+}
+class QuotaExceededError extends WebrpcError {
+  constructor(name = 'QuotaExceeded', code = 1200, message = 'Quota exceeded', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, QuotaExceededError.prototype);
+  }
+}
+class RateLimitError extends WebrpcError {
+  constructor(name = 'RateLimit', code = 1201, message = 'Rate limit exceeded', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, RateLimitError.prototype);
+  }
+}
+class NoDefaultKeyError extends WebrpcError {
+  constructor(name = 'NoDefaultKey', code = 1300, message = 'No default access key found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, NoDefaultKeyError.prototype);
+  }
+}
+class MaxAccessKeysError extends WebrpcError {
+  constructor(name = 'MaxAccessKeys', code = 1301, message = 'Access keys limit reached', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, MaxAccessKeysError.prototype);
+  }
+}
+class AtLeastOneKeyError extends WebrpcError {
+  constructor(name = 'AtLeastOneKey', code = 1302, message = 'You need at least one Access Key', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, AtLeastOneKeyError.prototype);
+  }
+}
+class TimeoutError extends WebrpcError {
+  constructor(name = 'Timeout', code = 1900, message = 'Request timed out', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, TimeoutError.prototype);
+  }
+}
+class InvalidArgumentError extends WebrpcError {
+  constructor(name = 'InvalidArgument', code = 2001, message = 'Invalid argument', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, InvalidArgumentError.prototype);
+  }
+}
+class UnavailableError extends WebrpcError {
+  constructor(name = 'Unavailable', code = 2002, message = 'Unavailable resource', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, UnavailableError.prototype);
+  }
+}
+class QueryFailedError extends WebrpcError {
+  constructor(name = 'QueryFailed', code = 2003, message = 'Query failed', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, QueryFailedError.prototype);
+  }
+}
+class ResourceExhaustedError extends WebrpcError {
+  constructor(name = 'ResourceExhausted', code = 2004, message = 'Resource exhausted', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, ResourceExhaustedError.prototype);
+  }
+}
+class NotFoundError extends WebrpcError {
+  constructor(name = 'NotFound', code = 3000, message = 'Resource not found', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, NotFoundError.prototype);
+  }
+}
+class MetadataCallFailedError extends WebrpcError {
+  constructor(name = 'MetadataCallFailed', code = 3003, message = 'Metadata service call failed', status = 0, cause) {
+    super(name, code, message, status, cause);
+    Object.setPrototypeOf(this, MetadataCallFailedError.prototype);
+  }
+}
+let errors = /*#__PURE__*/function (errors) {
+  errors["WebrpcEndpoint"] = "WebrpcEndpoint";
+  errors["WebrpcRequestFailed"] = "WebrpcRequestFailed";
+  errors["WebrpcBadRoute"] = "WebrpcBadRoute";
+  errors["WebrpcBadMethod"] = "WebrpcBadMethod";
+  errors["WebrpcBadRequest"] = "WebrpcBadRequest";
+  errors["WebrpcBadResponse"] = "WebrpcBadResponse";
+  errors["WebrpcServerPanic"] = "WebrpcServerPanic";
+  errors["WebrpcInternalError"] = "WebrpcInternalError";
+  errors["WebrpcClientDisconnected"] = "WebrpcClientDisconnected";
+  errors["WebrpcStreamLost"] = "WebrpcStreamLost";
+  errors["WebrpcStreamFinished"] = "WebrpcStreamFinished";
+  errors["Unauthorized"] = "Unauthorized";
+  errors["PermissionDenied"] = "PermissionDenied";
+  errors["SessionExpired"] = "SessionExpired";
+  errors["MethodNotFound"] = "MethodNotFound";
+  errors["RequestConflict"] = "RequestConflict";
+  errors["Aborted"] = "Aborted";
+  errors["Geoblocked"] = "Geoblocked";
+  errors["RateLimited"] = "RateLimited";
+  errors["ProjectNotFound"] = "ProjectNotFound";
+  errors["AccessKeyNotFound"] = "AccessKeyNotFound";
+  errors["AccessKeyMismatch"] = "AccessKeyMismatch";
+  errors["InvalidOrigin"] = "InvalidOrigin";
+  errors["InvalidService"] = "InvalidService";
+  errors["UnauthorizedUser"] = "UnauthorizedUser";
+  errors["QuotaExceeded"] = "QuotaExceeded";
+  errors["RateLimit"] = "RateLimit";
+  errors["NoDefaultKey"] = "NoDefaultKey";
+  errors["MaxAccessKeys"] = "MaxAccessKeys";
+  errors["AtLeastOneKey"] = "AtLeastOneKey";
+  errors["Timeout"] = "Timeout";
+  errors["InvalidArgument"] = "InvalidArgument";
+  errors["Unavailable"] = "Unavailable";
+  errors["QueryFailed"] = "QueryFailed";
+  errors["ResourceExhausted"] = "ResourceExhausted";
+  errors["NotFound"] = "NotFound";
+  errors["MetadataCallFailed"] = "MetadataCallFailed";
+  return errors;
+}({});
+const webrpcErrorByCode = {
+  [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,
+  [1006]: GeoblockedError,
+  [1007]: RateLimitedError,
+  [1100]: ProjectNotFoundError,
+  [1101]: AccessKeyNotFoundError,
+  [1102]: AccessKeyMismatchError,
+  [1103]: InvalidOriginError,
+  [1104]: InvalidServiceError,
+  [1105]: UnauthorizedUserError,
+  [1200]: QuotaExceededError,
+  [1201]: RateLimitError,
+  [1300]: NoDefaultKeyError,
+  [1301]: MaxAccessKeysError,
+  [1302]: AtLeastOneKeyError,
+  [1900]: TimeoutError,
+  [2001]: InvalidArgumentError,
+  [2002]: UnavailableError,
+  [2003]: QueryFailedError,
+  [2004]: ResourceExhaustedError,
+  [3000]: NotFoundError,
+  [3003]: MetadataCallFailedError
+};
+
+var indexergw_gen = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  WebrpcHeader: WebrpcHeader,
+  WebrpcHeaderValue: WebrpcHeaderValue,
+  WebRPCVersion: WebRPCVersion,
+  WebRPCSchemaVersion: WebRPCSchemaVersion,
+  WebRPCSchemaHash: WebRPCSchemaHash,
+  VersionFromHeader: VersionFromHeader,
+  ContractType: ContractType,
+  EventLogType: EventLogType,
+  EventLogDataType: EventLogDataType,
+  OrderStatus: OrderStatus,
+  TxnTransferType: TxnTransferType,
+  TransactionStatus: TransactionStatus,
+  TransactionType: TransactionType,
+  SortOrder: SortOrder,
+  ContractVerificationStatus: ContractVerificationStatus,
+  IndexerGateway: IndexerGateway,
+  WebrpcError: WebrpcError,
+  WebrpcEndpointError: WebrpcEndpointError,
+  WebrpcRequestFailedError: WebrpcRequestFailedError,
+  WebrpcBadRouteError: WebrpcBadRouteError,
+  WebrpcBadMethodError: WebrpcBadMethodError,
+  WebrpcBadRequestError: WebrpcBadRequestError,
+  WebrpcBadResponseError: WebrpcBadResponseError,
+  WebrpcServerPanicError: WebrpcServerPanicError,
+  WebrpcInternalErrorError: WebrpcInternalErrorError,
+  WebrpcClientDisconnectedError: WebrpcClientDisconnectedError,
+  WebrpcStreamLostError: WebrpcStreamLostError,
+  WebrpcStreamFinishedError: WebrpcStreamFinishedError,
+  UnauthorizedError: UnauthorizedError,
+  PermissionDeniedError: PermissionDeniedError,
+  SessionExpiredError: SessionExpiredError,
+  MethodNotFoundError: MethodNotFoundError,
+  RequestConflictError: RequestConflictError,
+  AbortedError: AbortedError,
+  GeoblockedError: GeoblockedError,
+  RateLimitedError: RateLimitedError,
+  ProjectNotFoundError: ProjectNotFoundError,
+  AccessKeyNotFoundError: AccessKeyNotFoundError,
+  AccessKeyMismatchError: AccessKeyMismatchError,
+  InvalidOriginError: InvalidOriginError,
+  InvalidServiceError: InvalidServiceError,
+  UnauthorizedUserError: UnauthorizedUserError,
+  QuotaExceededError: QuotaExceededError,
+  RateLimitError: RateLimitError,
+  NoDefaultKeyError: NoDefaultKeyError,
+  MaxAccessKeysError: MaxAccessKeysError,
+  AtLeastOneKeyError: AtLeastOneKeyError,
+  TimeoutError: TimeoutError,
+  InvalidArgumentError: InvalidArgumentError,
+  UnavailableError: UnavailableError,
+  QueryFailedError: QueryFailedError,
+  ResourceExhaustedError: ResourceExhaustedError,
+  NotFoundError: NotFoundError,
+  MetadataCallFailedError: MetadataCallFailedError,
+  errors: errors
+});
+
+class SequenceIndexer extends Indexer {
+  constructor(hostname, projectAccessKey, jwtAuth) {
+    super(hostname.endsWith('/') ? hostname.slice(0, -1) : hostname, fetch);
+    this.projectAccessKey = projectAccessKey;
+    this.jwtAuth = jwtAuth;
+    this._fetch = (input, init) => {
+      // automatically include jwt and access key auth header to requests
+      // if its been set on the api client
+      const headers = {};
+      const jwtAuth = this.jwtAuth;
+      const projectAccessKey = this.projectAccessKey;
+      if (jwtAuth && jwtAuth.length > 0) {
+        headers['Authorization'] = `BEARER ${jwtAuth}`;
+      }
+      if (projectAccessKey && projectAccessKey.length > 0) {
+        headers['X-Access-Key'] = projectAccessKey;
+      }
+
+      // before the request is made
+      init.headers = _extends({}, init.headers, headers);
+      return fetch(input, init);
+    };
+    this.fetch = this._fetch;
+  }
+}
+class SequenceIndexerGateway extends IndexerGateway {
   constructor(hostname, projectAccessKey, jwtAuth) {
     super(hostname.endsWith('/') ? hostname.slice(0, -1) : hostname, fetch);
     this.projectAccessKey = projectAccessKey;
@@ -891,44 +1599,46 @@ class SequenceIndexer extends Indexer {
   }
 }
 
-exports.AbortedError = AbortedError;
-exports.ContractType = ContractType;
-exports.ContractVerificationStatus = ContractVerificationStatus;
-exports.EventLogDataType = EventLogDataType;
-exports.EventLogType = EventLogType;
+exports.AbortedError = AbortedError$1;
+exports.ContractType = ContractType$1;
+exports.ContractVerificationStatus = ContractVerificationStatus$1;
+exports.EventLogDataType = EventLogDataType$1;
+exports.EventLogType = EventLogType$1;
 exports.Indexer = Indexer;
-exports.InvalidArgumentError = InvalidArgumentError;
-exports.MetadataCallFailedError = MetadataCallFailedError;
-exports.MethodNotFoundError = MethodNotFoundError;
-exports.NotFoundError = NotFoundError;
-exports.OrderStatus = OrderStatus;
-exports.PermissionDeniedError = PermissionDeniedError;
-exports.ProjectNotFoundError = ProjectNotFoundError;
-exports.QueryFailedError = QueryFailedError;
-exports.RequestConflictError = RequestConflictError;
-exports.ResourceExhaustedError = ResourceExhaustedError;
+exports.IndexerGateway = indexergw_gen;
+exports.InvalidArgumentError = InvalidArgumentError$1;
+exports.MetadataCallFailedError = MetadataCallFailedError$1;
+exports.MethodNotFoundError = MethodNotFoundError$1;
+exports.NotFoundError = NotFoundError$1;
+exports.OrderStatus = OrderStatus$1;
+exports.PermissionDeniedError = PermissionDeniedError$1;
+exports.ProjectNotFoundError = ProjectNotFoundError$1;
+exports.QueryFailedError = QueryFailedError$1;
+exports.RequestConflictError = RequestConflictError$1;
+exports.ResourceExhaustedError = ResourceExhaustedError$1;
 exports.SequenceIndexer = SequenceIndexer;
-exports.SessionExpiredError = SessionExpiredError;
-exports.SortOrder = SortOrder;
-exports.TimeoutError = TimeoutError;
-exports.TransactionStatus = TransactionStatus;
-exports.TransactionType = TransactionType;
-exports.TxnTransferType = TxnTransferType;
-exports.UnauthorizedError = UnauthorizedError;
-exports.UnavailableError = UnavailableError;
-exports.WebRPCSchemaHash = WebRPCSchemaHash;
-exports.WebRPCSchemaVersion = WebRPCSchemaVersion;
-exports.WebRPCVersion = WebRPCVersion;
-exports.WebrpcBadMethodError = WebrpcBadMethodError;
-exports.WebrpcBadRequestError = WebrpcBadRequestError;
-exports.WebrpcBadResponseError = WebrpcBadResponseError;
-exports.WebrpcBadRouteError = WebrpcBadRouteError;
-exports.WebrpcClientDisconnectedError = WebrpcClientDisconnectedError;
-exports.WebrpcEndpointError = WebrpcEndpointError;
-exports.WebrpcError = WebrpcError;
-exports.WebrpcInternalErrorError = WebrpcInternalErrorError;
-exports.WebrpcRequestFailedError = WebrpcRequestFailedError;
-exports.WebrpcServerPanicError = WebrpcServerPanicError;
-exports.WebrpcStreamFinishedError = WebrpcStreamFinishedError;
-exports.WebrpcStreamLostError = WebrpcStreamLostError;
-exports.errors = errors;
+exports.SequenceIndexerGateway = SequenceIndexerGateway;
+exports.SessionExpiredError = SessionExpiredError$1;
+exports.SortOrder = SortOrder$1;
+exports.TimeoutError = TimeoutError$1;
+exports.TransactionStatus = TransactionStatus$1;
+exports.TransactionType = TransactionType$1;
+exports.TxnTransferType = TxnTransferType$1;
+exports.UnauthorizedError = UnauthorizedError$1;
+exports.UnavailableError = UnavailableError$1;
+exports.WebRPCSchemaHash = WebRPCSchemaHash$1;
+exports.WebRPCSchemaVersion = WebRPCSchemaVersion$1;
+exports.WebRPCVersion = WebRPCVersion$1;
+exports.WebrpcBadMethodError = WebrpcBadMethodError$1;
+exports.WebrpcBadRequestError = WebrpcBadRequestError$1;
+exports.WebrpcBadResponseError = WebrpcBadResponseError$1;
+exports.WebrpcBadRouteError = WebrpcBadRouteError$1;
+exports.WebrpcClientDisconnectedError = WebrpcClientDisconnectedError$1;
+exports.WebrpcEndpointError = WebrpcEndpointError$1;
+exports.WebrpcError = WebrpcError$1;
+exports.WebrpcInternalErrorError = WebrpcInternalErrorError$1;
+exports.WebrpcRequestFailedError = WebrpcRequestFailedError$1;
+exports.WebrpcServerPanicError = WebrpcServerPanicError$1;
+exports.WebrpcStreamFinishedError = WebrpcStreamFinishedError$1;
+exports.WebrpcStreamLostError = WebrpcStreamLostError$1;
+exports.errors = errors$1;