@0xsequence/api 2.0.16 → 2.0.18

package/src/api.gen.ts

@@ -6,19 +6,18 @@
 // webrpc-gen -schema=api.ridl -target=typescript -client -out=./clients/api.gen.ts
 
 // WebRPC description and code-gen version
-export const WebRPCVersion = "v1"
+export const WebRPCVersion = 'v1'
 
 // Schema version of your RIDL schema
-export const WebRPCSchemaVersion = "v0.4.0"
+export const WebRPCSchemaVersion = 'v0.4.0'
 
 // Schema hash generated from your RIDL schema
-export const WebRPCSchemaHash = "470a0f88ea399c2a57ff8c22da54358c033ed5f0"
+export const WebRPCSchemaHash = '470a0f88ea399c2a57ff8c22da54358c033ed5f0'
 
 //
 // Types
 //
 
-
 export enum SortOrder {
   DESC = 'DESC',
   ASC = 'ASC'
@@ -59,7 +58,7 @@ export interface RuntimeStatus {
   branch: string
   commitHash: string
   checks: RuntimeChecks
-  numTxnsRelayed: {[key: string]: NumTxnsRelayed}
+  numTxnsRelayed: { [key: string]: NumTxnsRelayed }
 }
 
 export interface NumTxnsRelayed {
@@ -69,8 +68,7 @@ export interface NumTxnsRelayed {
   period: number
 }
 
-export interface RuntimeChecks {
-}
+export interface RuntimeChecks {}
 
 export interface SequenceContext {
   factory: string
@@ -442,16 +440,28 @@ export interface API {
   getSequenceContext(headers?: object, signal?: AbortSignal): Promise<GetSequenceContextReturn>
   getAuthToken(args: GetAuthTokenArgs, headers?: object, signal?: AbortSignal): Promise<GetAuthTokenReturn>
   getAuthToken2(args: GetAuthToken2Args, headers?: object, signal?: AbortSignal): Promise<GetAuthToken2Return>
-  sendPasswordlessLink(args: SendPasswordlessLinkArgs, headers?: object, signal?: AbortSignal): Promise<SendPasswordlessLinkReturn>
+  sendPasswordlessLink(
+    args: SendPasswordlessLinkArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SendPasswordlessLinkReturn>
   friendList(args: FriendListArgs, headers?: object, signal?: AbortSignal): Promise<FriendListReturn>
   getFriendByAddress(args: GetFriendByAddressArgs, headers?: object, signal?: AbortSignal): Promise<GetFriendByAddressReturn>
   searchFriends(args: SearchFriendsArgs, headers?: object, signal?: AbortSignal): Promise<SearchFriendsReturn>
   addFriend(args: AddFriendArgs, headers?: object, signal?: AbortSignal): Promise<AddFriendReturn>
-  updateFriendNickname(args: UpdateFriendNicknameArgs, headers?: object, signal?: AbortSignal): Promise<UpdateFriendNicknameReturn>
+  updateFriendNickname(
+    args: UpdateFriendNicknameArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateFriendNicknameReturn>
   removeFriend(args: RemoveFriendArgs, headers?: object, signal?: AbortSignal): Promise<RemoveFriendReturn>
   contractCall(args: ContractCallArgs, headers?: object, signal?: AbortSignal): Promise<ContractCallReturn>
   decodeContractCall(args: DecodeContractCallArgs, headers?: object, signal?: AbortSignal): Promise<DecodeContractCallReturn>
-  lookupContractCallSelectors(args: LookupContractCallSelectorsArgs, headers?: object, signal?: AbortSignal): Promise<LookupContractCallSelectorsReturn>
+  lookupContractCallSelectors(
+    args: LookupContractCallSelectorsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<LookupContractCallSelectorsReturn>
   userStorageFetch(args: UserStorageFetchArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageFetchReturn>
   userStorageSave(args: UserStorageSaveArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageSaveReturn>
   userStorageDelete(args: UserStorageDeleteArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageDeleteReturn>
@@ -459,77 +469,140 @@ export interface API {
   getMoonpayLink(args: GetMoonpayLinkArgs, headers?: object, signal?: AbortSignal): Promise<GetMoonpayLinkReturn>
   resolveENSAddress(args: ResolveENSAddressArgs, headers?: object, signal?: AbortSignal): Promise<ResolveENSAddressReturn>
   isValidSignature(args: IsValidSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidSignatureReturn>
-  isValidMessageSignature(args: IsValidMessageSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidMessageSignatureReturn>
-  isValidTypedDataSignature(args: IsValidTypedDataSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidTypedDataSignatureReturn>
+  isValidMessageSignature(
+    args: IsValidMessageSignatureArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<IsValidMessageSignatureReturn>
+  isValidTypedDataSignature(
+    args: IsValidTypedDataSignatureArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<IsValidTypedDataSignatureReturn>
   isValidETHAuthProof(args: IsValidETHAuthProofArgs, headers?: object, signal?: AbortSignal): Promise<IsValidETHAuthProofReturn>
   sardineGetClientToken(headers?: object, signal?: AbortSignal): Promise<SardineGetClientTokenReturn>
-  sardineGetNFTCheckoutToken(args: SardineGetNFTCheckoutTokenArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetNFTCheckoutTokenReturn>
-  sardineGetNFTCheckoutOrderStatus(args: SardineGetNFTCheckoutOrderStatusArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetNFTCheckoutOrderStatusReturn>
+  sardineGetNFTCheckoutToken(
+    args: SardineGetNFTCheckoutTokenArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SardineGetNFTCheckoutTokenReturn>
+  sardineGetNFTCheckoutOrderStatus(
+    args: SardineGetNFTCheckoutOrderStatusArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SardineGetNFTCheckoutOrderStatusReturn>
   sardineGetSupportedRegions(headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedRegionsReturn>
   sardineGetSupportedFiatCurrencies(headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedFiatCurrenciesReturn>
   sardineGetSupportedTokens(headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedTokensReturn>
   sardineGetEnabledTokens(headers?: object, signal?: AbortSignal): Promise<SardineGetEnabledTokensReturn>
   sardineGetQuote(args: SardineGetQuoteArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetQuoteReturn>
   getSardineClientToken(headers?: object, signal?: AbortSignal): Promise<GetSardineClientTokenReturn>
-  getSardineNFTCheckoutToken(args: GetSardineNFTCheckoutTokenArgs, headers?: object, signal?: AbortSignal): Promise<GetSardineNFTCheckoutTokenReturn>
-  getSardineNFTCheckoutOrderStatus(args: GetSardineNFTCheckoutOrderStatusArgs, headers?: object, signal?: AbortSignal): Promise<GetSardineNFTCheckoutOrderStatusReturn>
+  getSardineNFTCheckoutToken(
+    args: GetSardineNFTCheckoutTokenArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetSardineNFTCheckoutTokenReturn>
+  getSardineNFTCheckoutOrderStatus(
+    args: GetSardineNFTCheckoutOrderStatusArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetSardineNFTCheckoutOrderStatusReturn>
   getCoinPrices(args: GetCoinPricesArgs, headers?: object, signal?: AbortSignal): Promise<GetCoinPricesReturn>
-  getCollectiblePrices(args: GetCollectiblePricesArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectiblePricesReturn>
+  getCollectiblePrices(
+    args: GetCollectiblePricesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectiblePricesReturn>
   getExchangeRate(args: GetExchangeRateArgs, headers?: object, signal?: AbortSignal): Promise<GetExchangeRateReturn>
   memoryStore(args: MemoryStoreArgs, headers?: object, signal?: AbortSignal): Promise<MemoryStoreReturn>
   memoryLoad(args: MemoryLoadArgs, headers?: object, signal?: AbortSignal): Promise<MemoryLoadReturn>
   getInviteInfo(headers?: object, signal?: AbortSignal): Promise<GetInviteInfoReturn>
   isValidAccessCode(args: IsValidAccessCodeArgs, headers?: object, signal?: AbortSignal): Promise<IsValidAccessCodeReturn>
-  internalClaimAccessCode(args: InternalClaimAccessCodeArgs, headers?: object, signal?: AbortSignal): Promise<InternalClaimAccessCodeReturn>
+  internalClaimAccessCode(
+    args: InternalClaimAccessCodeArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<InternalClaimAccessCodeReturn>
   blockNumberAtTime(args: BlockNumberAtTimeArgs, headers?: object, signal?: AbortSignal): Promise<BlockNumberAtTimeReturn>
   paperSessionSecret(args: PaperSessionSecretArgs, headers?: object, signal?: AbortSignal): Promise<PaperSessionSecretReturn>
   paperSessionSecret2(args: PaperSessionSecret2Args, headers?: object, signal?: AbortSignal): Promise<PaperSessionSecret2Return>
   linkWallet(args: LinkWalletArgs, headers?: object, signal?: AbortSignal): Promise<LinkWalletReturn>
   getLinkedWallets(args: GetLinkedWalletsArgs, headers?: object, signal?: AbortSignal): Promise<GetLinkedWalletsReturn>
   removeLinkedWallet(args: RemoveLinkedWalletArgs, headers?: object, signal?: AbortSignal): Promise<RemoveLinkedWalletReturn>
-  generateWaaSVerificationURL(args: GenerateWaaSVerificationURLArgs, headers?: object, signal?: AbortSignal): Promise<GenerateWaaSVerificationURLReturn>
-  validateWaaSVerificationNonce(args: ValidateWaaSVerificationNonceArgs, headers?: object, signal?: AbortSignal): Promise<ValidateWaaSVerificationNonceReturn>
+  generateWaaSVerificationURL(
+    args: GenerateWaaSVerificationURLArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateWaaSVerificationURLReturn>
+  validateWaaSVerificationNonce(
+    args: ValidateWaaSVerificationNonceArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ValidateWaaSVerificationNonceReturn>
   getSwapPrices(args: GetSwapPricesArgs, headers?: object, signal?: AbortSignal): Promise<GetSwapPricesReturn>
   getSwapQuote(args: GetSwapQuoteArgs, headers?: object, signal?: AbortSignal): Promise<GetSwapQuoteReturn>
   listCurrencyGroups(headers?: object, signal?: AbortSignal): Promise<ListCurrencyGroupsReturn>
-  addOffchainInventory(args: AddOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<AddOffchainInventoryReturn>
-  getOffchainInventory(args: GetOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<GetOffchainInventoryReturn>
-  listOffchainInventories(args: ListOffchainInventoriesArgs, headers?: object, signal?: AbortSignal): Promise<ListOffchainInventoriesReturn>
-  updateOffchainInventory(args: UpdateOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<UpdateOffchainInventoryReturn>
-  deleteOffchainInventory(args: DeleteOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<DeleteOffchainInventoryReturn>
-  requestOffchainPayment(args: RequestOffchainPaymentArgs, headers?: object, signal?: AbortSignal): Promise<RequestOffchainPaymentReturn>
-  listOffchainPayments(args: ListOffchainPaymentsArgs, headers?: object, signal?: AbortSignal): Promise<ListOffchainPaymentsReturn>
-}
-
-export interface PingArgs {
-}
+  addOffchainInventory(
+    args: AddOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<AddOffchainInventoryReturn>
+  getOffchainInventory(
+    args: GetOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetOffchainInventoryReturn>
+  listOffchainInventories(
+    args: ListOffchainInventoriesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffchainInventoriesReturn>
+  updateOffchainInventory(
+    args: UpdateOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateOffchainInventoryReturn>
+  deleteOffchainInventory(
+    args: DeleteOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteOffchainInventoryReturn>
+  requestOffchainPayment(
+    args: RequestOffchainPaymentArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<RequestOffchainPaymentReturn>
+  listOffchainPayments(
+    args: ListOffchainPaymentsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffchainPaymentsReturn>
+}
+
+export interface PingArgs {}
 
 export interface PingReturn {
-  status: boolean  
-}
-export interface VersionArgs {
+  status: boolean
 }
+export interface VersionArgs {}
 
 export interface VersionReturn {
-  version: Version  
-}
-export interface RuntimeStatusArgs {
+  version: Version
 }
+export interface RuntimeStatusArgs {}
 
 export interface RuntimeStatusReturn {
-  status: RuntimeStatus  
-}
-export interface ClockArgs {
+  status: RuntimeStatus
 }
+export interface ClockArgs {}
 
 export interface ClockReturn {
-  serverTime: string  
-}
-export interface GetSequenceContextArgs {
+  serverTime: string
 }
+export interface GetSequenceContextArgs {}
 
 export interface GetSequenceContextReturn {
-  data: SequenceContext  
+  data: SequenceContext
 }
 export interface GetAuthTokenArgs {
   ewtString: string
@@ -540,7 +613,7 @@ export interface GetAuthTokenReturn {
   status: boolean
   jwtToken: string
   address: string
-  user?: User  
+  user?: User
 }
 export interface GetAuthToken2Args {
   ewtString: string
@@ -551,7 +624,7 @@ export interface GetAuthToken2Return {
   status: boolean
   jwtToken: string
   address: string
-  user?: User  
+  user?: User
 }
 export interface SendPasswordlessLinkArgs {
   email: string
@@ -560,7 +633,7 @@ export interface SendPasswordlessLinkArgs {
 }
 
 export interface SendPasswordlessLinkReturn {
-  status: boolean  
+  status: boolean
 }
 export interface FriendListArgs {
   nickname?: string
@@ -569,7 +642,7 @@ export interface FriendListArgs {
 
 export interface FriendListReturn {
   page: Page
-  friends: Array<Friend>  
+  friends: Array<Friend>
 }
 export interface GetFriendByAddressArgs {
   friendAddress: string
@@ -577,7 +650,7 @@ export interface GetFriendByAddressArgs {
 
 export interface GetFriendByAddressReturn {
   status: boolean
-  friend: Friend  
+  friend: Friend
 }
 export interface SearchFriendsArgs {
   filterUsername: string
@@ -585,7 +658,7 @@ export interface SearchFriendsArgs {
 }
 
 export interface SearchFriendsReturn {
-  friends: Array<Friend>  
+  friends: Array<Friend>
 }
 export interface AddFriendArgs {
   friendAddress: string
@@ -594,7 +667,7 @@ export interface AddFriendArgs {
 
 export interface AddFriendReturn {
   status: boolean
-  friend?: Friend  
+  friend?: Friend
 }
 export interface UpdateFriendNicknameArgs {
   friendAddress: string
@@ -603,14 +676,14 @@ export interface UpdateFriendNicknameArgs {
 
 export interface UpdateFriendNicknameReturn {
   status: boolean
-  friend?: Friend  
+  friend?: Friend
 }
 export interface RemoveFriendArgs {
   friendAddress: string
 }
 
 export interface RemoveFriendReturn {
-  status: boolean  
+  status: boolean
 }
 export interface ContractCallArgs {
   chainID: string
@@ -621,28 +694,28 @@ export interface ContractCallArgs {
 }
 
 export interface ContractCallReturn {
-  returns: Array<string>  
+  returns: Array<string>
 }
 export interface DecodeContractCallArgs {
   callData: string
 }
 
 export interface DecodeContractCallReturn {
-  call: ContractCall  
+  call: ContractCall
 }
 export interface LookupContractCallSelectorsArgs {
   selectors: Array<string>
 }
 
 export interface LookupContractCallSelectorsReturn {
-  signatures: Array<Array<string>>  
+  signatures: Array<Array<string>>
 }
 export interface UserStorageFetchArgs {
   key: string
 }
 
 export interface UserStorageFetchReturn {
-  object: any  
+  object: any
 }
 export interface UserStorageSaveArgs {
   key: string
@@ -650,28 +723,28 @@ export interface UserStorageSaveArgs {
 }
 
 export interface UserStorageSaveReturn {
-  ok: boolean  
+  ok: boolean
 }
 export interface UserStorageDeleteArgs {
   key: string
 }
 
 export interface UserStorageDeleteReturn {
-  ok: boolean  
+  ok: boolean
 }
 export interface UserStorageFetchAllArgs {
   keys?: Array<string>
 }
 
 export interface UserStorageFetchAllReturn {
-  objects: {[key: string]: any}  
+  objects: { [key: string]: any }
 }
 export interface GetMoonpayLinkArgs {
   url: string
 }
 
 export interface GetMoonpayLinkReturn {
-  signedUrl: string  
+  signedUrl: string
 }
 export interface ResolveENSAddressArgs {
   ens: string
@@ -679,7 +752,7 @@ export interface ResolveENSAddressArgs {
 
 export interface ResolveENSAddressReturn {
   address: string
-  ok: boolean  
+  ok: boolean
 }
 export interface IsValidSignatureArgs {
   chainId: string
@@ -689,7 +762,7 @@ export interface IsValidSignatureArgs {
 }
 
 export interface IsValidSignatureReturn {
-  isValid: boolean  
+  isValid: boolean
 }
 export interface IsValidMessageSignatureArgs {
   chainId: string
@@ -699,7 +772,7 @@ export interface IsValidMessageSignatureArgs {
 }
 
 export interface IsValidMessageSignatureReturn {
-  isValid: boolean  
+  isValid: boolean
 }
 export interface IsValidTypedDataSignatureArgs {
   chainId: string
@@ -709,7 +782,7 @@ export interface IsValidTypedDataSignatureArgs {
 }
 
 export interface IsValidTypedDataSignatureReturn {
-  isValid: boolean  
+  isValid: boolean
 }
 export interface IsValidETHAuthProofArgs {
   chainId: string
@@ -718,99 +791,93 @@ export interface IsValidETHAuthProofArgs {
 }
 
 export interface IsValidETHAuthProofReturn {
-  isValid: boolean  
-}
-export interface SardineGetClientTokenArgs {
+  isValid: boolean
 }
+export interface SardineGetClientTokenArgs {}
 
 export interface SardineGetClientTokenReturn {
-  token: string  
+  token: string
 }
 export interface SardineGetNFTCheckoutTokenArgs {
   params: SardineNFTCheckoutParams
 }
 
 export interface SardineGetNFTCheckoutTokenReturn {
-  resp: SardineNFTCheckout  
+  resp: SardineNFTCheckout
 }
 export interface SardineGetNFTCheckoutOrderStatusArgs {
   orderId: string
 }
 
 export interface SardineGetNFTCheckoutOrderStatusReturn {
-  resp: SardineOrder  
-}
-export interface SardineGetSupportedRegionsArgs {
+  resp: SardineOrder
 }
+export interface SardineGetSupportedRegionsArgs {}
 
 export interface SardineGetSupportedRegionsReturn {
-  regions: Array<SardineRegion>  
-}
-export interface SardineGetSupportedFiatCurrenciesArgs {
+  regions: Array<SardineRegion>
 }
+export interface SardineGetSupportedFiatCurrenciesArgs {}
 
 export interface SardineGetSupportedFiatCurrenciesReturn {
-  tokens: Array<SardineFiatCurrency>  
-}
-export interface SardineGetSupportedTokensArgs {
+  tokens: Array<SardineFiatCurrency>
 }
+export interface SardineGetSupportedTokensArgs {}
 
 export interface SardineGetSupportedTokensReturn {
-  tokens: Array<SardineSupportedToken>  
-}
-export interface SardineGetEnabledTokensArgs {
+  tokens: Array<SardineSupportedToken>
 }
+export interface SardineGetEnabledTokensArgs {}
 
 export interface SardineGetEnabledTokensReturn {
-  tokens: Array<SardineEnabledToken>  
+  tokens: Array<SardineEnabledToken>
 }
 export interface SardineGetQuoteArgs {
   params: SardineGetQuoteParams
 }
 
 export interface SardineGetQuoteReturn {
-  quote: SardineQuote  
-}
-export interface GetSardineClientTokenArgs {
+  quote: SardineQuote
 }
+export interface GetSardineClientTokenArgs {}
 
 export interface GetSardineClientTokenReturn {
-  token: string  
+  token: string
 }
 export interface GetSardineNFTCheckoutTokenArgs {
   params: SardineNFTCheckoutParams
 }
 
 export interface GetSardineNFTCheckoutTokenReturn {
-  resp: SardineNFTCheckout  
+  resp: SardineNFTCheckout
 }
 export interface GetSardineNFTCheckoutOrderStatusArgs {
   orderId: string
 }
 
 export interface GetSardineNFTCheckoutOrderStatusReturn {
-  resp: SardineOrder  
+  resp: SardineOrder
 }
 export interface GetCoinPricesArgs {
   tokens: Array<Token>
 }
 
 export interface GetCoinPricesReturn {
-  tokenPrices: Array<TokenPrice>  
+  tokenPrices: Array<TokenPrice>
 }
 export interface GetCollectiblePricesArgs {
   tokens: Array<Token>
 }
 
 export interface GetCollectiblePricesReturn {
-  tokenPrices: Array<TokenPrice>  
+  tokenPrices: Array<TokenPrice>
 }
 export interface GetExchangeRateArgs {
   toCurrency: string
 }
 
 export interface GetExchangeRateReturn {
-  exchangeRate: ExchangeRate  
+  exchangeRate: ExchangeRate
 }
 export interface MemoryStoreArgs {
   key: string
@@ -818,27 +885,26 @@ export interface MemoryStoreArgs {
 }
 
 export interface MemoryStoreReturn {
-  ok: boolean  
+  ok: boolean
 }
 export interface MemoryLoadArgs {
   key: string
 }
 
 export interface MemoryLoadReturn {
-  value: string  
-}
-export interface GetInviteInfoArgs {
+  value: string
 }
+export interface GetInviteInfoArgs {}
 
 export interface GetInviteInfoReturn {
-  inviteInfo: InviteInfo  
+  inviteInfo: InviteInfo
 }
 export interface IsValidAccessCodeArgs {
   accessCode: string
 }
 
 export interface IsValidAccessCodeReturn {
-  status: boolean  
+  status: boolean
 }
 export interface InternalClaimAccessCodeArgs {
   address: string
@@ -846,7 +912,7 @@ export interface InternalClaimAccessCodeArgs {
 }
 
 export interface InternalClaimAccessCodeReturn {
-  status: boolean  
+  status: boolean
 }
 export interface BlockNumberAtTimeArgs {
   chainId: number
@@ -854,7 +920,7 @@ export interface BlockNumberAtTimeArgs {
 }
 
 export interface BlockNumberAtTimeReturn {
-  blocks: Array<number>  
+  blocks: Array<number>
 }
 export interface PaperSessionSecretArgs {
   chainName: string
@@ -864,7 +930,7 @@ export interface PaperSessionSecretArgs {
 }
 
 export interface PaperSessionSecretReturn {
-  secret: string  
+  secret: string
 }
 export interface PaperSessionSecret2Args {
   chainName: string
@@ -874,7 +940,7 @@ export interface PaperSessionSecret2Args {
 }
 
 export interface PaperSessionSecret2Return {
-  secret: string  
+  secret: string
 }
 export interface LinkWalletArgs {
   parentWalletAddress: string
@@ -888,7 +954,7 @@ export interface LinkWalletArgs {
 }
 
 export interface LinkWalletReturn {
-  status: boolean  
+  status: boolean
 }
 export interface GetLinkedWalletsArgs {
   parentWalletAddress: string
@@ -898,7 +964,7 @@ export interface GetLinkedWalletsArgs {
 }
 
 export interface GetLinkedWalletsReturn {
-  linkedWallets: Array<LinkedWallet>  
+  linkedWallets: Array<LinkedWallet>
 }
 export interface RemoveLinkedWalletArgs {
   parentWalletAddress: string
@@ -911,7 +977,7 @@ export interface RemoveLinkedWalletArgs {
 }
 
 export interface RemoveLinkedWalletReturn {
-  status: boolean  
+  status: boolean
 }
 export interface GenerateWaaSVerificationURLArgs {
   walletAddress: string
@@ -919,7 +985,7 @@ export interface GenerateWaaSVerificationURLArgs {
 
 export interface GenerateWaaSVerificationURLReturn {
   nonce: string
-  verificationURL: string  
+  verificationURL: string
 }
 export interface ValidateWaaSVerificationNonceArgs {
   nonce: string
@@ -929,7 +995,7 @@ export interface ValidateWaaSVerificationNonceArgs {
 }
 
 export interface ValidateWaaSVerificationNonceReturn {
-  walletAddress: string  
+  walletAddress: string
 }
 export interface GetSwapPricesArgs {
   userAddress: string
@@ -939,7 +1005,7 @@ export interface GetSwapPricesArgs {
 }
 
 export interface GetSwapPricesReturn {
-  swapPrices: Array<SwapPrice>  
+  swapPrices: Array<SwapPrice>
 }
 export interface GetSwapQuoteArgs {
   userAddress: string
@@ -951,47 +1017,45 @@ export interface GetSwapQuoteArgs {
 }
 
 export interface GetSwapQuoteReturn {
-  swapQuote: SwapQuote  
-}
-export interface ListCurrencyGroupsArgs {
+  swapQuote: SwapQuote
 }
+export interface ListCurrencyGroupsArgs {}
 
 export interface ListCurrencyGroupsReturn {
-  currencyGroups: Array<CurrencyGroup>  
+  currencyGroups: Array<CurrencyGroup>
 }
 export interface AddOffchainInventoryArgs {
   inventory: OffchainInventory
 }
 
 export interface AddOffchainInventoryReturn {
-  inventoryId: number  
+  inventoryId: number
 }
 export interface GetOffchainInventoryArgs {
   inventoryId: number
 }
 
 export interface GetOffchainInventoryReturn {
-  inventory: OffchainInventory  
+  inventory: OffchainInventory
 }
 export interface ListOffchainInventoriesArgs {
   projectId: number
 }
 
 export interface ListOffchainInventoriesReturn {
-  inventory: Array<OffchainInventory>  
+  inventory: Array<OffchainInventory>
 }
 export interface UpdateOffchainInventoryArgs {
   inventory: OffchainInventory
 }
 
-export interface UpdateOffchainInventoryReturn {  
-}
+export interface UpdateOffchainInventoryReturn {}
 export interface DeleteOffchainInventoryArgs {
   inventoryId: number
 }
 
 export interface DeleteOffchainInventoryReturn {
-  ok: boolean  
+  ok: boolean
 }
 export interface RequestOffchainPaymentArgs {
   inventoryId: number
@@ -1001,7 +1065,7 @@ export interface RequestOffchainPaymentArgs {
 }
 
 export interface RequestOffchainPaymentReturn {
-  payment: PaymentResponse  
+  payment: PaymentResponse
 }
 export interface ListOffchainPaymentsArgs {
   inventoryId: number
@@ -1010,11 +1074,9 @@ export interface ListOffchainPaymentsArgs {
 
 export interface ListOffchainPaymentsReturn {
   page: Page
-  payments: Array<OffchainPayment>  
+  payments: Array<OffchainPayment>
 }
 
-
-  
 //
 // Client
 //
@@ -1031,930 +1093,1091 @@ export class API implements API {
   private url(name: string): string {
     return this.hostname + this.path + name
   }
-  
+
   ping = (headers?: object, signal?: AbortSignal): Promise<PingReturn> => {
-    return this.fetch(
-      this.url('Ping'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    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, 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 || ''}` })
-    })
+    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, 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 || ''}` })
-    })
+    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 || ''}` })
+      }
+    )
   }
-  
+
   clock = (headers?: object, signal?: AbortSignal): Promise<ClockReturn> => {
-    return this.fetch(
-      this.url('Clock'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          serverTime: <string>(_data.serverTime),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('Clock'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            serverTime: <string>_data.serverTime
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getSequenceContext = (headers?: object, signal?: AbortSignal): Promise<GetSequenceContextReturn> => {
-    return this.fetch(
-      this.url('GetSequenceContext'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          data: <SequenceContext>(_data.data),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetSequenceContext'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            data: <SequenceContext>_data.data
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getAuthToken = (args: GetAuthTokenArgs, headers?: object, signal?: AbortSignal): Promise<GetAuthTokenReturn> => {
-    return this.fetch(
-      this.url('GetAuthToken'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-          jwtToken: <string>(_data.jwtToken),
-          address: <string>(_data.address),
-          user: <User>(_data.user),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetAuthToken'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status,
+            jwtToken: <string>_data.jwtToken,
+            address: <string>_data.address,
+            user: <User>_data.user
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getAuthToken2 = (args: GetAuthToken2Args, headers?: object, signal?: AbortSignal): Promise<GetAuthToken2Return> => {
-    return this.fetch(
-      this.url('GetAuthToken2'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-          jwtToken: <string>(_data.jwtToken),
-          address: <string>(_data.address),
-          user: <User>(_data.user),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  sendPasswordlessLink = (args: SendPasswordlessLinkArgs, headers?: object, signal?: AbortSignal): Promise<SendPasswordlessLinkReturn> => {
-    return this.fetch(
-      this.url('SendPasswordlessLink'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetAuthToken2'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status,
+            jwtToken: <string>_data.jwtToken,
+            address: <string>_data.address,
+            user: <User>_data.user
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  sendPasswordlessLink = (
+    args: SendPasswordlessLinkArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SendPasswordlessLinkReturn> => {
+    return this.fetch(this.url('SendPasswordlessLink'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   friendList = (args: FriendListArgs, headers?: object, signal?: AbortSignal): Promise<FriendListReturn> => {
-    return this.fetch(
-      this.url('FriendList'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>(_data.page),
-          friends: <Array<Friend>>(_data.friends),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getFriendByAddress = (args: GetFriendByAddressArgs, headers?: object, signal?: AbortSignal): Promise<GetFriendByAddressReturn> => {
-    return this.fetch(
-      this.url('GetFriendByAddress'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-          friend: <Friend>(_data.friend),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('FriendList'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: <Page>_data.page,
+            friends: <Array<Friend>>_data.friends
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  getFriendByAddress = (
+    args: GetFriendByAddressArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetFriendByAddressReturn> => {
+    return this.fetch(this.url('GetFriendByAddress'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status,
+            friend: <Friend>_data.friend
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   searchFriends = (args: SearchFriendsArgs, headers?: object, signal?: AbortSignal): Promise<SearchFriendsReturn> => {
-    return this.fetch(
-      this.url('SearchFriends'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          friends: <Array<Friend>>(_data.friends),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SearchFriends'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            friends: <Array<Friend>>_data.friends
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   addFriend = (args: AddFriendArgs, headers?: object, signal?: AbortSignal): Promise<AddFriendReturn> => {
-    return this.fetch(
-      this.url('AddFriend'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-          friend: <Friend>(_data.friend),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  updateFriendNickname = (args: UpdateFriendNicknameArgs, headers?: object, signal?: AbortSignal): Promise<UpdateFriendNicknameReturn> => {
-    return this.fetch(
-      this.url('UpdateFriendNickname'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-          friend: <Friend>(_data.friend),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('AddFriend'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status,
+            friend: <Friend>_data.friend
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  updateFriendNickname = (
+    args: UpdateFriendNicknameArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateFriendNicknameReturn> => {
+    return this.fetch(this.url('UpdateFriendNickname'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status,
+            friend: <Friend>_data.friend
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   removeFriend = (args: RemoveFriendArgs, headers?: object, signal?: AbortSignal): Promise<RemoveFriendReturn> => {
-    return this.fetch(
-      this.url('RemoveFriend'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('RemoveFriend'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   contractCall = (args: ContractCallArgs, headers?: object, signal?: AbortSignal): Promise<ContractCallReturn> => {
-    return this.fetch(
-      this.url('ContractCall'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          returns: <Array<string>>(_data.returns),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  decodeContractCall = (args: DecodeContractCallArgs, headers?: object, signal?: AbortSignal): Promise<DecodeContractCallReturn> => {
-    return this.fetch(
-      this.url('DecodeContractCall'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          call: <ContractCall>(_data.call),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  lookupContractCallSelectors = (args: LookupContractCallSelectorsArgs, headers?: object, signal?: AbortSignal): Promise<LookupContractCallSelectorsReturn> => {
-    return this.fetch(
-      this.url('LookupContractCallSelectors'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          signatures: <Array<Array<string>>>(_data.signatures),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('ContractCall'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            returns: <Array<string>>_data.returns
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  decodeContractCall = (
+    args: DecodeContractCallArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DecodeContractCallReturn> => {
+    return this.fetch(this.url('DecodeContractCall'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            call: <ContractCall>_data.call
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  lookupContractCallSelectors = (
+    args: LookupContractCallSelectorsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<LookupContractCallSelectorsReturn> => {
+    return this.fetch(this.url('LookupContractCallSelectors'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            signatures: <Array<Array<string>>>_data.signatures
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   userStorageFetch = (args: UserStorageFetchArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageFetchReturn> => {
-    return this.fetch(
-      this.url('UserStorageFetch'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          object: <any>(_data.object),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('UserStorageFetch'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            object: <any>_data.object
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   userStorageSave = (args: UserStorageSaveArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageSaveReturn> => {
-    return this.fetch(
-      this.url('UserStorageSave'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          ok: <boolean>(_data.ok),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('UserStorageSave'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            ok: <boolean>_data.ok
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   userStorageDelete = (args: UserStorageDeleteArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageDeleteReturn> => {
-    return this.fetch(
-      this.url('UserStorageDelete'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          ok: <boolean>(_data.ok),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  userStorageFetchAll = (args: UserStorageFetchAllArgs, headers?: object, signal?: AbortSignal): Promise<UserStorageFetchAllReturn> => {
-    return this.fetch(
-      this.url('UserStorageFetchAll'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          objects: <{[key: string]: any}>(_data.objects),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('UserStorageDelete'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            ok: <boolean>_data.ok
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  userStorageFetchAll = (
+    args: UserStorageFetchAllArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UserStorageFetchAllReturn> => {
+    return this.fetch(this.url('UserStorageFetchAll'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            objects: <{ [key: string]: any }>_data.objects
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getMoonpayLink = (args: GetMoonpayLinkArgs, headers?: object, signal?: AbortSignal): Promise<GetMoonpayLinkReturn> => {
-    return this.fetch(
-      this.url('GetMoonpayLink'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          signedUrl: <string>(_data.signedUrl),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetMoonpayLink'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            signedUrl: <string>_data.signedUrl
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   resolveENSAddress = (args: ResolveENSAddressArgs, headers?: object, signal?: AbortSignal): Promise<ResolveENSAddressReturn> => {
-    return this.fetch(
-      this.url('ResolveENSAddress'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          address: <string>(_data.address),
-          ok: <boolean>(_data.ok),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('ResolveENSAddress'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            address: <string>_data.address,
+            ok: <boolean>_data.ok
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   isValidSignature = (args: IsValidSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidSignatureReturn> => {
-    return this.fetch(
-      this.url('IsValidSignature'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          isValid: <boolean>(_data.isValid),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  isValidMessageSignature = (args: IsValidMessageSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidMessageSignatureReturn> => {
-    return this.fetch(
-      this.url('IsValidMessageSignature'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          isValid: <boolean>(_data.isValid),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  isValidTypedDataSignature = (args: IsValidTypedDataSignatureArgs, headers?: object, signal?: AbortSignal): Promise<IsValidTypedDataSignatureReturn> => {
-    return this.fetch(
-      this.url('IsValidTypedDataSignature'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          isValid: <boolean>(_data.isValid),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  isValidETHAuthProof = (args: IsValidETHAuthProofArgs, headers?: object, signal?: AbortSignal): Promise<IsValidETHAuthProofReturn> => {
-    return this.fetch(
-      this.url('IsValidETHAuthProof'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          isValid: <boolean>(_data.isValid),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('IsValidSignature'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            isValid: <boolean>_data.isValid
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  isValidMessageSignature = (
+    args: IsValidMessageSignatureArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<IsValidMessageSignatureReturn> => {
+    return this.fetch(this.url('IsValidMessageSignature'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            isValid: <boolean>_data.isValid
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  isValidTypedDataSignature = (
+    args: IsValidTypedDataSignatureArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<IsValidTypedDataSignatureReturn> => {
+    return this.fetch(this.url('IsValidTypedDataSignature'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            isValid: <boolean>_data.isValid
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  isValidETHAuthProof = (
+    args: IsValidETHAuthProofArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<IsValidETHAuthProofReturn> => {
+    return this.fetch(this.url('IsValidETHAuthProof'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            isValid: <boolean>_data.isValid
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   sardineGetClientToken = (headers?: object, signal?: AbortSignal): Promise<SardineGetClientTokenReturn> => {
-    return this.fetch(
-      this.url('SardineGetClientToken'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          token: <string>(_data.token),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  sardineGetNFTCheckoutToken = (args: SardineGetNFTCheckoutTokenArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetNFTCheckoutTokenReturn> => {
-    return this.fetch(
-      this.url('SardineGetNFTCheckoutToken'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          resp: <SardineNFTCheckout>(_data.resp),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  sardineGetNFTCheckoutOrderStatus = (args: SardineGetNFTCheckoutOrderStatusArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetNFTCheckoutOrderStatusReturn> => {
-    return this.fetch(
-      this.url('SardineGetNFTCheckoutOrderStatus'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          resp: <SardineOrder>(_data.resp),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SardineGetClientToken'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            token: <string>_data.token
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  sardineGetNFTCheckoutToken = (
+    args: SardineGetNFTCheckoutTokenArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SardineGetNFTCheckoutTokenReturn> => {
+    return this.fetch(this.url('SardineGetNFTCheckoutToken'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            resp: <SardineNFTCheckout>_data.resp
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  sardineGetNFTCheckoutOrderStatus = (
+    args: SardineGetNFTCheckoutOrderStatusArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SardineGetNFTCheckoutOrderStatusReturn> => {
+    return this.fetch(this.url('SardineGetNFTCheckoutOrderStatus'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            resp: <SardineOrder>_data.resp
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   sardineGetSupportedRegions = (headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedRegionsReturn> => {
-    return this.fetch(
-      this.url('SardineGetSupportedRegions'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          regions: <Array<SardineRegion>>(_data.regions),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  sardineGetSupportedFiatCurrencies = (headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedFiatCurrenciesReturn> => {
-    return this.fetch(
-      this.url('SardineGetSupportedFiatCurrencies'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          tokens: <Array<SardineFiatCurrency>>(_data.tokens),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SardineGetSupportedRegions'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            regions: <Array<SardineRegion>>_data.regions
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  sardineGetSupportedFiatCurrencies = (
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<SardineGetSupportedFiatCurrenciesReturn> => {
+    return this.fetch(this.url('SardineGetSupportedFiatCurrencies'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            tokens: <Array<SardineFiatCurrency>>_data.tokens
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   sardineGetSupportedTokens = (headers?: object, signal?: AbortSignal): Promise<SardineGetSupportedTokensReturn> => {
-    return this.fetch(
-      this.url('SardineGetSupportedTokens'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          tokens: <Array<SardineSupportedToken>>(_data.tokens),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SardineGetSupportedTokens'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            tokens: <Array<SardineSupportedToken>>_data.tokens
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   sardineGetEnabledTokens = (headers?: object, signal?: AbortSignal): Promise<SardineGetEnabledTokensReturn> => {
-    return this.fetch(
-      this.url('SardineGetEnabledTokens'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          tokens: <Array<SardineEnabledToken>>(_data.tokens),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SardineGetEnabledTokens'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            tokens: <Array<SardineEnabledToken>>_data.tokens
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   sardineGetQuote = (args: SardineGetQuoteArgs, headers?: object, signal?: AbortSignal): Promise<SardineGetQuoteReturn> => {
-    return this.fetch(
-      this.url('SardineGetQuote'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          quote: <SardineQuote>(_data.quote),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('SardineGetQuote'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            quote: <SardineQuote>_data.quote
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getSardineClientToken = (headers?: object, signal?: AbortSignal): Promise<GetSardineClientTokenReturn> => {
-    return this.fetch(
-      this.url('GetSardineClientToken'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          token: <string>(_data.token),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getSardineNFTCheckoutToken = (args: GetSardineNFTCheckoutTokenArgs, headers?: object, signal?: AbortSignal): Promise<GetSardineNFTCheckoutTokenReturn> => {
-    return this.fetch(
-      this.url('GetSardineNFTCheckoutToken'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          resp: <SardineNFTCheckout>(_data.resp),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getSardineNFTCheckoutOrderStatus = (args: GetSardineNFTCheckoutOrderStatusArgs, headers?: object, signal?: AbortSignal): Promise<GetSardineNFTCheckoutOrderStatusReturn> => {
-    return this.fetch(
-      this.url('GetSardineNFTCheckoutOrderStatus'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          resp: <SardineOrder>(_data.resp),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetSardineClientToken'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            token: <string>_data.token
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  getSardineNFTCheckoutToken = (
+    args: GetSardineNFTCheckoutTokenArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetSardineNFTCheckoutTokenReturn> => {
+    return this.fetch(this.url('GetSardineNFTCheckoutToken'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            resp: <SardineNFTCheckout>_data.resp
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  getSardineNFTCheckoutOrderStatus = (
+    args: GetSardineNFTCheckoutOrderStatusArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetSardineNFTCheckoutOrderStatusReturn> => {
+    return this.fetch(this.url('GetSardineNFTCheckoutOrderStatus'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            resp: <SardineOrder>_data.resp
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getCoinPrices = (args: GetCoinPricesArgs, headers?: object, signal?: AbortSignal): Promise<GetCoinPricesReturn> => {
-    return this.fetch(
-      this.url('GetCoinPrices'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          tokenPrices: <Array<TokenPrice>>(_data.tokenPrices),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getCollectiblePrices = (args: GetCollectiblePricesArgs, headers?: object, signal?: AbortSignal): Promise<GetCollectiblePricesReturn> => {
-    return this.fetch(
-      this.url('GetCollectiblePrices'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          tokenPrices: <Array<TokenPrice>>(_data.tokenPrices),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetCoinPrices'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            tokenPrices: <Array<TokenPrice>>_data.tokenPrices
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  getCollectiblePrices = (
+    args: GetCollectiblePricesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetCollectiblePricesReturn> => {
+    return this.fetch(this.url('GetCollectiblePrices'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            tokenPrices: <Array<TokenPrice>>_data.tokenPrices
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getExchangeRate = (args: GetExchangeRateArgs, headers?: object, signal?: AbortSignal): Promise<GetExchangeRateReturn> => {
-    return this.fetch(
-      this.url('GetExchangeRate'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          exchangeRate: <ExchangeRate>(_data.exchangeRate),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetExchangeRate'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            exchangeRate: <ExchangeRate>_data.exchangeRate
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   memoryStore = (args: MemoryStoreArgs, headers?: object, signal?: AbortSignal): Promise<MemoryStoreReturn> => {
-    return this.fetch(
-      this.url('MemoryStore'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          ok: <boolean>(_data.ok),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('MemoryStore'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            ok: <boolean>_data.ok
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   memoryLoad = (args: MemoryLoadArgs, headers?: object, signal?: AbortSignal): Promise<MemoryLoadReturn> => {
-    return this.fetch(
-      this.url('MemoryLoad'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          value: <string>(_data.value),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('MemoryLoad'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            value: <string>_data.value
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getInviteInfo = (headers?: object, signal?: AbortSignal): Promise<GetInviteInfoReturn> => {
-    return this.fetch(
-      this.url('GetInviteInfo'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          inviteInfo: <InviteInfo>(_data.inviteInfo),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetInviteInfo'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            inviteInfo: <InviteInfo>_data.inviteInfo
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   isValidAccessCode = (args: IsValidAccessCodeArgs, headers?: object, signal?: AbortSignal): Promise<IsValidAccessCodeReturn> => {
-    return this.fetch(
-      this.url('IsValidAccessCode'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  internalClaimAccessCode = (args: InternalClaimAccessCodeArgs, headers?: object, signal?: AbortSignal): Promise<InternalClaimAccessCodeReturn> => {
-    return this.fetch(
-      this.url('InternalClaimAccessCode'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('IsValidAccessCode'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  internalClaimAccessCode = (
+    args: InternalClaimAccessCodeArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<InternalClaimAccessCodeReturn> => {
+    return this.fetch(this.url('InternalClaimAccessCode'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   blockNumberAtTime = (args: BlockNumberAtTimeArgs, headers?: object, signal?: AbortSignal): Promise<BlockNumberAtTimeReturn> => {
-    return this.fetch(
-      this.url('BlockNumberAtTime'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          blocks: <Array<number>>(_data.blocks),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  paperSessionSecret = (args: PaperSessionSecretArgs, headers?: object, signal?: AbortSignal): Promise<PaperSessionSecretReturn> => {
-    return this.fetch(
-      this.url('PaperSessionSecret'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          secret: <string>(_data.secret),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  paperSessionSecret2 = (args: PaperSessionSecret2Args, headers?: object, signal?: AbortSignal): Promise<PaperSessionSecret2Return> => {
-    return this.fetch(
-      this.url('PaperSessionSecret2'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          secret: <string>(_data.secret),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('BlockNumberAtTime'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            blocks: <Array<number>>_data.blocks
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  paperSessionSecret = (
+    args: PaperSessionSecretArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<PaperSessionSecretReturn> => {
+    return this.fetch(this.url('PaperSessionSecret'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            secret: <string>_data.secret
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  paperSessionSecret2 = (
+    args: PaperSessionSecret2Args,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<PaperSessionSecret2Return> => {
+    return this.fetch(this.url('PaperSessionSecret2'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            secret: <string>_data.secret
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   linkWallet = (args: LinkWalletArgs, headers?: object, signal?: AbortSignal): Promise<LinkWalletReturn> => {
-    return this.fetch(
-      this.url('LinkWallet'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('LinkWallet'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getLinkedWallets = (args: GetLinkedWalletsArgs, headers?: object, signal?: AbortSignal): Promise<GetLinkedWalletsReturn> => {
-    return this.fetch(
-      this.url('GetLinkedWallets'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          linkedWallets: <Array<LinkedWallet>>(_data.linkedWallets),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  removeLinkedWallet = (args: RemoveLinkedWalletArgs, headers?: object, signal?: AbortSignal): Promise<RemoveLinkedWalletReturn> => {
-    return this.fetch(
-      this.url('RemoveLinkedWallet'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          status: <boolean>(_data.status),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  generateWaaSVerificationURL = (args: GenerateWaaSVerificationURLArgs, headers?: object, signal?: AbortSignal): Promise<GenerateWaaSVerificationURLReturn> => {
-    return this.fetch(
-      this.url('GenerateWaaSVerificationURL'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          nonce: <string>(_data.nonce),
-          verificationURL: <string>(_data.verificationURL),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  validateWaaSVerificationNonce = (args: ValidateWaaSVerificationNonceArgs, headers?: object, signal?: AbortSignal): Promise<ValidateWaaSVerificationNonceReturn> => {
-    return this.fetch(
-      this.url('ValidateWaaSVerificationNonce'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          walletAddress: <string>(_data.walletAddress),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetLinkedWallets'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            linkedWallets: <Array<LinkedWallet>>_data.linkedWallets
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  removeLinkedWallet = (
+    args: RemoveLinkedWalletArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<RemoveLinkedWalletReturn> => {
+    return this.fetch(this.url('RemoveLinkedWallet'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            status: <boolean>_data.status
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  generateWaaSVerificationURL = (
+    args: GenerateWaaSVerificationURLArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GenerateWaaSVerificationURLReturn> => {
+    return this.fetch(this.url('GenerateWaaSVerificationURL'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            nonce: <string>_data.nonce,
+            verificationURL: <string>_data.verificationURL
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  validateWaaSVerificationNonce = (
+    args: ValidateWaaSVerificationNonceArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ValidateWaaSVerificationNonceReturn> => {
+    return this.fetch(this.url('ValidateWaaSVerificationNonce'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            walletAddress: <string>_data.walletAddress
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getSwapPrices = (args: GetSwapPricesArgs, headers?: object, signal?: AbortSignal): Promise<GetSwapPricesReturn> => {
-    return this.fetch(
-      this.url('GetSwapPrices'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          swapPrices: <Array<SwapPrice>>(_data.swapPrices),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetSwapPrices'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            swapPrices: <Array<SwapPrice>>_data.swapPrices
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   getSwapQuote = (args: GetSwapQuoteArgs, headers?: object, signal?: AbortSignal): Promise<GetSwapQuoteReturn> => {
-    return this.fetch(
-      this.url('GetSwapQuote'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          swapQuote: <SwapQuote>(_data.swapQuote),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('GetSwapQuote'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            swapQuote: <SwapQuote>_data.swapQuote
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
+
   listCurrencyGroups = (headers?: object, signal?: AbortSignal): Promise<ListCurrencyGroupsReturn> => {
-    return this.fetch(
-      this.url('ListCurrencyGroups'),
-      createHTTPRequest({}, headers, signal)
-      ).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          currencyGroups: <Array<CurrencyGroup>>(_data.currencyGroups),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  addOffchainInventory = (args: AddOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<AddOffchainInventoryReturn> => {
-    return this.fetch(
-      this.url('AddOffchainInventory'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          inventoryId: <number>(_data.inventoryId),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  getOffchainInventory = (args: GetOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<GetOffchainInventoryReturn> => {
-    return this.fetch(
-      this.url('GetOffchainInventory'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          inventory: <OffchainInventory>(_data.inventory),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listOffchainInventories = (args: ListOffchainInventoriesArgs, headers?: object, signal?: AbortSignal): Promise<ListOffchainInventoriesReturn> => {
-    return this.fetch(
-      this.url('ListOffchainInventories'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          inventory: <Array<OffchainInventory>>(_data.inventory),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  updateOffchainInventory = (args: UpdateOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<UpdateOffchainInventoryReturn> => {
-    return this.fetch(
-      this.url('UpdateOffchainInventory'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {}
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  deleteOffchainInventory = (args: DeleteOffchainInventoryArgs, headers?: object, signal?: AbortSignal): Promise<DeleteOffchainInventoryReturn> => {
-    return this.fetch(
-      this.url('DeleteOffchainInventory'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          ok: <boolean>(_data.ok),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  requestOffchainPayment = (args: RequestOffchainPaymentArgs, headers?: object, signal?: AbortSignal): Promise<RequestOffchainPaymentReturn> => {
-    return this.fetch(
-      this.url('RequestOffchainPayment'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          payment: <PaymentResponse>(_data.payment),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
-  }
-  
-  listOffchainPayments = (args: ListOffchainPaymentsArgs, headers?: object, signal?: AbortSignal): Promise<ListOffchainPaymentsReturn> => {
-    return this.fetch(
-      this.url('ListOffchainPayments'),
-      createHTTPRequest(args, headers, signal)).then((res) => {
-      return buildResponse(res).then(_data => {
-        return {
-          page: <Page>(_data.page),
-          payments: <Array<OffchainPayment>>(_data.payments),
-        }
-      })
-    }, (error) => {
-      throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
-    })
+    return this.fetch(this.url('ListCurrencyGroups'), createHTTPRequest({}, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            currencyGroups: <Array<CurrencyGroup>>_data.currencyGroups
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  addOffchainInventory = (
+    args: AddOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<AddOffchainInventoryReturn> => {
+    return this.fetch(this.url('AddOffchainInventory'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            inventoryId: <number>_data.inventoryId
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  getOffchainInventory = (
+    args: GetOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<GetOffchainInventoryReturn> => {
+    return this.fetch(this.url('GetOffchainInventory'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            inventory: <OffchainInventory>_data.inventory
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  listOffchainInventories = (
+    args: ListOffchainInventoriesArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffchainInventoriesReturn> => {
+    return this.fetch(this.url('ListOffchainInventories'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            inventory: <Array<OffchainInventory>>_data.inventory
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  updateOffchainInventory = (
+    args: UpdateOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<UpdateOffchainInventoryReturn> => {
+    return this.fetch(this.url('UpdateOffchainInventory'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {}
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  deleteOffchainInventory = (
+    args: DeleteOffchainInventoryArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<DeleteOffchainInventoryReturn> => {
+    return this.fetch(this.url('DeleteOffchainInventory'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            ok: <boolean>_data.ok
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  requestOffchainPayment = (
+    args: RequestOffchainPaymentArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<RequestOffchainPaymentReturn> => {
+    return this.fetch(this.url('RequestOffchainPayment'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            payment: <PaymentResponse>_data.payment
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
+  }
+
+  listOffchainPayments = (
+    args: ListOffchainPaymentsArgs,
+    headers?: object,
+    signal?: AbortSignal
+  ): Promise<ListOffchainPaymentsReturn> => {
+    return this.fetch(this.url('ListOffchainPayments'), createHTTPRequest(args, headers, signal)).then(
+      res => {
+        return buildResponse(res).then(_data => {
+          return {
+            page: <Page>_data.page,
+            payments: <Array<OffchainPayment>>_data.payments
+          }
+        })
+      },
+      error => {
+        throw WebrpcRequestFailedError.new({ cause: `fetch(): ${error.message || ''}` })
+      }
+    )
   }
-  
 }
 
-  const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
+const createHTTPRequest = (body: object = {}, headers: object = {}, signal: AbortSignal | null = null): object => {
   return {
     method: 'POST',
     headers: { ...headers, 'Content-Type': 'application/json' },
@@ -1968,18 +2191,18 @@ const buildResponse = (res: Response): Promise<any> => {
     let data
     try {
       data = JSON.parse(text)
-    } catch(error) {
+    } catch (error) {
       let message = ''
-      if (error instanceof Error)  {
+      if (error instanceof Error) {
         message = error.message
       }
       throw WebrpcBadResponseError.new({
         status: res.status,
-        cause: `JSON.parse(): ${message}: response text: ${text}`},
-      )
+        cause: `JSON.parse(): ${message}: response text: ${text}`
+      })
     }
     if (!res.ok) {
-      const code: number = (typeof data.code === 'number') ? data.code : 0
+      const code: number = typeof data.code === 'number' ? data.code : 0
       throw (webrpcErrorByCode[code] || WebrpcError).new(data)
     }
     return data
@@ -2161,7 +2384,6 @@ export class WebrpcStreamFinishedError extends WebrpcError {
   }
 }
 
-
 // Schema errors
 
 export class UnauthorizedError extends WebrpcError {
@@ -2281,7 +2503,6 @@ export class NotFoundError extends WebrpcError {
   }
 }
 
-
 export enum errors {
   WebrpcEndpoint = 'WebrpcEndpoint',
   WebrpcRequestFailed = 'WebrpcRequestFailed',
@@ -2302,7 +2523,7 @@ export enum errors {
   InvalidArgument = 'InvalidArgument',
   Unavailable = 'Unavailable',
   QueryFailed = 'QueryFailed',
-  NotFound = 'NotFound',
+  NotFound = 'NotFound'
 }
 
 const webrpcErrorByCode: { [code: number]: any } = {
@@ -2325,8 +2546,7 @@ const webrpcErrorByCode: { [code: number]: any } = {
   [2000]: InvalidArgumentError,
   [2002]: UnavailableError,
   [2003]: QueryFailedError,
-  [3000]: NotFoundError,
+  [3000]: NotFoundError
 }
 
 export type Fetch = (input: RequestInfo, init?: RequestInit) => Promise<Response>
-