@chainflip/rpc 1.6.4 → 1.6.6

package/dist/parsers.mjs

@@ -0,0 +1,303 @@
+// src/parsers.ts
+import { isNotNullish } from "@chainflip/utils/guard";
+import { isHex } from "@chainflip/utils/string";
+import { z } from "zod";
+var hexString = z.string().refine(isHex, { message: "Invalid hex string" });
+var u256 = hexString.transform((value) => BigInt(value));
+var numberOrHex = z.union([z.number().transform((n) => BigInt(n)), u256]);
+var chainAssetMapFactory = (parser, defaultValue) => z.object({
+  Bitcoin: z.object({ BTC: parser }),
+  Ethereum: z.object({ ETH: parser, USDC: parser, FLIP: parser, USDT: parser }),
+  Polkadot: z.object({ DOT: parser }),
+  Arbitrum: z.object({ ETH: parser, USDC: parser }),
+  Solana: z.object({ SOL: parser.default(defaultValue), USDC: parser.default(defaultValue) }).default({ SOL: defaultValue, USDC: defaultValue })
+});
+var chainBaseAssetMapFactory = (parser, defaultValue) => z.object({
+  Bitcoin: z.object({ BTC: parser }),
+  Ethereum: z.object({ ETH: parser, FLIP: parser, USDT: parser }),
+  Polkadot: z.object({ DOT: parser }),
+  Arbitrum: z.object({ ETH: parser, USDC: parser }),
+  Solana: z.object({ SOL: parser.default(defaultValue), USDC: parser.default(defaultValue) }).default({ SOL: defaultValue, USDC: defaultValue })
+});
+var chainMapFactory = (parser, defaultValue) => z.object({
+  Bitcoin: parser,
+  Ethereum: parser,
+  Polkadot: parser,
+  Arbitrum: parser,
+  Solana: parser.default(defaultValue)
+});
+var rpcAssetSchema = z.union([
+  z.object({ chain: z.literal("Bitcoin"), asset: z.literal("BTC") }),
+  z.object({ chain: z.literal("Polkadot"), asset: z.literal("DOT") }),
+  z.object({ chain: z.literal("Ethereum"), asset: z.literal("FLIP") }),
+  z.object({ chain: z.literal("Ethereum"), asset: z.literal("ETH") }),
+  z.object({ chain: z.literal("Ethereum"), asset: z.literal("USDC") }),
+  z.object({ chain: z.literal("Ethereum"), asset: z.literal("USDT") }),
+  z.object({ chain: z.literal("Arbitrum"), asset: z.literal("ETH") }),
+  z.object({ chain: z.literal("Arbitrum"), asset: z.literal("USDC") }),
+  z.object({ chain: z.literal("Solana"), asset: z.literal("SOL") }),
+  z.object({ chain: z.literal("Solana"), asset: z.literal("USDC") })
+]);
+var rename = (mapping) => (obj) => Object.fromEntries(
+  Object.entries(obj).map(([key, value]) => [
+    key in mapping ? mapping[key] : key,
+    value
+  ])
+);
+var rpcBaseResponse = z.object({
+  id: z.union([z.string(), z.number()]),
+  jsonrpc: z.literal("2.0")
+});
+var nonNullish = z.any().refine(isNotNullish, { message: "Value must not be null or undefined" });
+var rpcSuccessResponse = rpcBaseResponse.extend({ result: nonNullish });
+var rpcErrorResponse = rpcBaseResponse.extend({
+  error: z.object({ code: z.number(), message: z.string() })
+});
+var rpcResponse = z.union([rpcSuccessResponse, rpcErrorResponse]);
+var cfSwapRate = z.object({
+  intermediary: numberOrHex.nullable(),
+  output: numberOrHex
+});
+var fee = z.intersection(rpcAssetSchema, z.object({ amount: numberOrHex }));
+var cfSwapRateV2 = z.object({
+  egress_fee: fee,
+  ingress_fee: fee,
+  intermediary: u256.nullable(),
+  network_fee: fee,
+  output: u256
+});
+var chainGetBlockHash = hexString;
+var stateGetMetadata = hexString;
+var stateGetRuntimeVersion = z.object({
+  specName: z.string(),
+  implName: z.string(),
+  authoringVersion: z.number(),
+  specVersion: z.number(),
+  implVersion: z.number(),
+  apis: z.array(z.tuple([hexString, z.number()])),
+  transactionVersion: z.number(),
+  stateVersion: z.number()
+});
+var cfIngressEgressEnvironment = z.object({
+  minimum_deposit_amounts: chainAssetMapFactory(numberOrHex, 0),
+  ingress_fees: chainAssetMapFactory(numberOrHex.nullable(), null),
+  egress_fees: chainAssetMapFactory(numberOrHex.nullable(), null),
+  witness_safety_margins: chainMapFactory(z.number().nullable(), null),
+  egress_dust_limits: chainAssetMapFactory(numberOrHex, 0),
+  channel_opening_fees: chainMapFactory(numberOrHex, 0),
+  // TODO(1.6): no longer optional
+  max_swap_retry_duration_blocks: chainMapFactory(z.number(), 0).optional().default({ Arbitrum: 0, Bitcoin: 0, Ethereum: 0, Polkadot: 0, Solana: 0 })
+}).transform(rename({ egress_dust_limits: "minimum_egress_amounts" }));
+var cfSwappingEnvironment = z.object({
+  maximum_swap_amounts: chainAssetMapFactory(numberOrHex.nullable(), null),
+  network_fee_hundredth_pips: z.number()
+});
+var cfFundingEnvironment = z.object({
+  redemption_tax: numberOrHex,
+  minimum_funding_amount: numberOrHex
+});
+var defaultFeeInfo = {
+  limit_order_fee_hundredth_pips: 0,
+  range_order_fee_hundredth_pips: 0,
+  range_order_total_fees_earned: { base: "0x0", quote: "0x0" },
+  limit_order_total_fees_earned: { base: "0x0", quote: "0x0" },
+  range_total_swap_inputs: { base: "0x0", quote: "0x0" },
+  limit_total_swap_inputs: { base: "0x0", quote: "0x0" },
+  quote_asset: { chain: "Ethereum", asset: "USDC" }
+};
+var cfPoolsEnvironment = z.object({
+  fees: chainBaseAssetMapFactory(
+    z.object({
+      limit_order_fee_hundredth_pips: z.number(),
+      range_order_fee_hundredth_pips: z.number(),
+      range_order_total_fees_earned: z.object({ base: u256, quote: u256 }),
+      limit_order_total_fees_earned: z.object({ base: u256, quote: u256 }),
+      range_total_swap_inputs: z.object({ base: u256, quote: u256 }),
+      limit_total_swap_inputs: z.object({ base: u256, quote: u256 }),
+      quote_asset: z.object({ chain: z.literal("Ethereum"), asset: z.literal("USDC") })
+    }).nullable().transform((info) => info ?? structuredClone(defaultFeeInfo)),
+    structuredClone(defaultFeeInfo)
+  )
+});
+var cfEnvironment = z.object({
+  ingress_egress: cfIngressEgressEnvironment,
+  swapping: cfSwappingEnvironment,
+  funding: cfFundingEnvironment,
+  pools: cfPoolsEnvironment
+});
+var cfBoostPoolsDepth = z.array(
+  z.intersection(rpcAssetSchema, z.object({ tier: z.number(), available_amount: u256 }))
+);
+var orderInfoSchema = z.object({
+  depth: numberOrHex,
+  price: numberOrHex.nullable()
+});
+var assetInfoSchema = z.object({
+  limit_orders: orderInfoSchema,
+  range_orders: orderInfoSchema
+});
+var cfPoolDepth = z.object({
+  asks: assetInfoSchema,
+  bids: assetInfoSchema
+}).nullable();
+var cfSupportedAssets = z.array(z.object({ chain: z.string(), asset: z.string() })).transform(
+  (assets) => assets.filter((asset) => rpcAssetSchema.safeParse(asset).success)
+);
+var brokerRequestSwapDepositAddress = z.object({
+  address: z.string(),
+  issued_block: z.number(),
+  channel_id: z.number(),
+  source_chain_expiry_block: numberOrHex,
+  channel_opening_fee: u256
+});
+var unregistered = z.object({
+  role: z.literal("unregistered"),
+  flip_balance: numberOrHex
+});
+var broker = z.object({
+  role: z.literal("broker"),
+  flip_balance: numberOrHex,
+  earned_fees: chainAssetMapFactory(numberOrHex, 0)
+});
+var boostBalances = z.array(
+  z.object({
+    fee_tier: z.number(),
+    total_balance: u256,
+    available_balance: u256,
+    in_use_balance: u256,
+    is_withdrawing: z.boolean()
+  })
+);
+var liquidityProvider = z.object({
+  role: z.literal("liquidity_provider"),
+  balances: chainAssetMapFactory(numberOrHex, "0x0"),
+  refund_addresses: chainMapFactory(z.string().nullable(), null),
+  flip_balance: numberOrHex,
+  earned_fees: chainAssetMapFactory(numberOrHex, 0),
+  boost_balances: chainAssetMapFactory(boostBalances, [])
+});
+var validator = z.object({
+  role: z.literal("validator"),
+  flip_balance: numberOrHex,
+  bond: numberOrHex,
+  last_heartbeat: z.number(),
+  reputation_points: z.number(),
+  keyholder_epochs: z.array(z.number()),
+  is_current_authority: z.boolean(),
+  is_current_backup: z.boolean(),
+  is_qualified: z.boolean(),
+  is_online: z.boolean(),
+  is_bidding: z.boolean(),
+  bound_redeem_address: hexString.nullable(),
+  apy_bp: z.number().nullable(),
+  restricted_balances: z.record(hexString, numberOrHex)
+});
+var cfAccountInfo = z.union([unregistered, broker, liquidityProvider, validator]);
+var cfAccounts = z.array(z.tuple([z.string(), z.string()]));
+var cfPoolPriceV2 = z.object({
+  sell: numberOrHex.nullable(),
+  buy: numberOrHex.nullable(),
+  range_order: numberOrHex,
+  base_asset: rpcAssetSchema,
+  quote_asset: rpcAssetSchema
+});
+var orderId = numberOrHex.transform((n) => String(n));
+var limitOrder = z.object({
+  id: orderId,
+  tick: z.number(),
+  sell_amount: numberOrHex,
+  fees_earned: numberOrHex,
+  original_sell_amount: numberOrHex,
+  lp: z.string()
+});
+var ask = limitOrder.transform((order) => ({
+  ...order,
+  type: "ask"
+}));
+var bid = limitOrder.transform((order) => ({
+  ...order,
+  type: "bid"
+}));
+var rangeOrder = z.object({
+  id: orderId,
+  range: z.object({ start: z.number(), end: z.number() }),
+  liquidity: numberOrHex,
+  fees_earned: z.object({ base: numberOrHex, quote: numberOrHex }),
+  lp: z.string()
+}).transform((order) => ({ ...order, type: "range" }));
+var cfPoolOrders = z.object({
+  limit_orders: z.object({
+    asks: z.array(ask),
+    bids: z.array(bid)
+  }),
+  range_orders: z.array(rangeOrder)
+});
+var boostPoolAmount = z.object({
+  account_id: z.string(),
+  amount: u256
+});
+var cfBoostPoolDetails = z.array(
+  z.intersection(
+    rpcAssetSchema,
+    z.object({
+      fee_tier: z.number(),
+      available_amounts: z.array(boostPoolAmount),
+      deposits_pending_finalization: z.array(
+        z.object({
+          deposit_id: z.number().transform(BigInt),
+          owed_amounts: z.array(boostPoolAmount)
+        })
+      ),
+      pending_withdrawals: z.array(
+        z.object({
+          account_id: z.string(),
+          pending_deposits: z.array(z.bigint())
+        })
+      )
+    })
+  )
+);
+var cfBoostPoolPendingFees = z.array(
+  z.intersection(
+    rpcAssetSchema,
+    z.object({
+      fee_tier: z.number(),
+      pending_fees: z.array(
+        z.object({
+          deposit_id: z.number().transform(BigInt),
+          fees: z.array(boostPoolAmount)
+        })
+      )
+    })
+  )
+);
+export {
+  broker,
+  brokerRequestSwapDepositAddress,
+  cfAccountInfo,
+  cfAccounts,
+  cfBoostPoolDetails,
+  cfBoostPoolPendingFees,
+  cfBoostPoolsDepth,
+  cfEnvironment,
+  cfFundingEnvironment,
+  cfIngressEgressEnvironment,
+  cfPoolDepth,
+  cfPoolOrders,
+  cfPoolPriceV2,
+  cfPoolsEnvironment,
+  cfSupportedAssets,
+  cfSwapRate,
+  cfSwapRateV2,
+  cfSwappingEnvironment,
+  chainGetBlockHash,
+  hexString,
+  liquidityProvider,
+  numberOrHex,
+  rpcResponse,
+  stateGetMetadata,
+  stateGetRuntimeVersion,
+  u256,
+  unregistered,
+  validator
+};

package/dist/types.d.cts

@@ -1,24 +1,45 @@
+import { z } from 'zod';
 import { RpcResult, RpcResponse } from './common.cjs';
 export { RpcMethod, RpcRequest as RpcParams } from './common.cjs';
-import 'zod';
-import './parsers.cjs';
+import { unregistered, broker, validator, liquidityProvider } from './parsers.cjs';
+export { RpcLimitOrder, RpcRangeOrder } from './parsers.cjs';
 import '@chainflip/utils/types';
 
+type CfAccountInfo = RpcResult<'cf_account_info'>;
+type CfBoostPoolDetails = RpcResult<'cf_boost_pool_details'>;
+type CfBoostPoolPendingFees = RpcResult<'cf_boost_pool_pending_fees'>;
 type CfBoostPoolsDepth = RpcResult<'cf_boost_pools_depth'>;
 type CfEnvironment = RpcResult<'cf_environment'>;
 type CfFundingEnvironment = RpcResult<'cf_funding_environment'>;
 type CfIngressEgressEnvironment = RpcResult<'cf_ingress_egress_environment'>;
+type CfPoolOrders = RpcResult<'cf_pool_orders'>;
+type CfPoolPriceV2 = RpcResult<'cf_pool_price_v2'>;
+type CfPoolsEnvironment = RpcResult<'cf_pools_environment'>;
 type CfSupportedAssets = RpcResult<'cf_supported_assets'>;
 type CfSwappingEnvironment = RpcResult<'cf_swapping_environment'>;
 type CfSwapRate = RpcResult<'cf_swap_rate'>;
 type CfSwapRateV2 = RpcResult<'cf_swap_rate_v2'>;
+type CfPoolDepth = RpcResult<'cf_pool_depth'>;
+type CfAccounts = RpcResult<'cf_accounts'>;
+type CfAccountInfoResponse = RpcResponse<'cf_account_info'>;
+type CfBoostPoolDetailsResponse = RpcResponse<'cf_boost_pool_details'>;
+type CfBoostPoolPendingFeesResponse = RpcResponse<'cf_boost_pool_pending_fees'>;
 type CfBoostPoolsDepthResponse = RpcResponse<'cf_boost_pools_depth'>;
 type CfEnvironmentResponse = RpcResponse<'cf_environment'>;
 type CfFundingEnvironmentResponse = RpcResponse<'cf_funding_environment'>;
 type CfIngressEgressEnvironmentResponse = RpcResponse<'cf_ingress_egress_environment'>;
+type CfPoolOrdersResponse = RpcResponse<'cf_pool_orders'>;
+type CfPoolPriceV2Response = RpcResponse<'cf_pool_price_v2'>;
+type CfPoolsEnvironmentResponse = RpcResponse<'cf_pools_environment'>;
 type CfSupportedAssetsResponse = RpcResponse<'cf_supported_assets'>;
 type CfSwappingEnvironmentResponse = RpcResponse<'cf_swapping_environment'>;
 type CfSwapRateResponse = RpcResponse<'cf_swap_rate'>;
 type CfSwapRateV2Response = RpcResponse<'cf_swap_rate_v2'>;
+type CfPoolDepthResponse = RpcResponse<'cf_pool_depth'>;
+type CfAccountsResponse = RpcResponse<'cf_accounts'>;
+type CfUnregisteredAccount = z.output<typeof unregistered>;
+type CfBrokerAccount = z.output<typeof broker>;
+type CfValidatorAccount = z.output<typeof validator>;
+type CfLiquidityProviderAccount = z.output<typeof liquidityProvider>;
 
-export { type CfBoostPoolsDepth, type CfBoostPoolsDepthResponse, type CfEnvironment, type CfEnvironmentResponse, type CfFundingEnvironment, type CfFundingEnvironmentResponse, type CfIngressEgressEnvironment, type CfIngressEgressEnvironmentResponse, type CfSupportedAssets, type CfSupportedAssetsResponse, type CfSwapRate, type CfSwapRateResponse, type CfSwapRateV2, type CfSwapRateV2Response, type CfSwappingEnvironment, type CfSwappingEnvironmentResponse, RpcResult };
+export { type CfAccountInfo, type CfAccountInfoResponse, type CfAccounts, type CfAccountsResponse, type CfBoostPoolDetails, type CfBoostPoolDetailsResponse, type CfBoostPoolPendingFees, type CfBoostPoolPendingFeesResponse, type CfBoostPoolsDepth, type CfBoostPoolsDepthResponse, type CfBrokerAccount, type CfEnvironment, type CfEnvironmentResponse, type CfFundingEnvironment, type CfFundingEnvironmentResponse, type CfIngressEgressEnvironment, type CfIngressEgressEnvironmentResponse, type CfLiquidityProviderAccount, type CfPoolDepth, type CfPoolDepthResponse, type CfPoolOrders, type CfPoolOrdersResponse, type CfPoolPriceV2, type CfPoolPriceV2Response, type CfPoolsEnvironment, type CfPoolsEnvironmentResponse, type CfSupportedAssets, type CfSupportedAssetsResponse, type CfSwapRate, type CfSwapRateResponse, type CfSwapRateV2, type CfSwapRateV2Response, type CfSwappingEnvironment, type CfSwappingEnvironmentResponse, type CfUnregisteredAccount, type CfValidatorAccount, RpcResult };

package/dist/types.d.ts

@@ -1,24 +1,45 @@
+import { z } from 'zod';
 import { RpcResult, RpcResponse } from './common.js';
 export { RpcMethod, RpcRequest as RpcParams } from './common.js';
-import 'zod';
-import './parsers.js';
+import { unregistered, broker, validator, liquidityProvider } from './parsers.js';
+export { RpcLimitOrder, RpcRangeOrder } from './parsers.js';
 import '@chainflip/utils/types';
 
+type CfAccountInfo = RpcResult<'cf_account_info'>;
+type CfBoostPoolDetails = RpcResult<'cf_boost_pool_details'>;
+type CfBoostPoolPendingFees = RpcResult<'cf_boost_pool_pending_fees'>;
 type CfBoostPoolsDepth = RpcResult<'cf_boost_pools_depth'>;
 type CfEnvironment = RpcResult<'cf_environment'>;
 type CfFundingEnvironment = RpcResult<'cf_funding_environment'>;
 type CfIngressEgressEnvironment = RpcResult<'cf_ingress_egress_environment'>;
+type CfPoolOrders = RpcResult<'cf_pool_orders'>;
+type CfPoolPriceV2 = RpcResult<'cf_pool_price_v2'>;
+type CfPoolsEnvironment = RpcResult<'cf_pools_environment'>;
 type CfSupportedAssets = RpcResult<'cf_supported_assets'>;
 type CfSwappingEnvironment = RpcResult<'cf_swapping_environment'>;
 type CfSwapRate = RpcResult<'cf_swap_rate'>;
 type CfSwapRateV2 = RpcResult<'cf_swap_rate_v2'>;
+type CfPoolDepth = RpcResult<'cf_pool_depth'>;
+type CfAccounts = RpcResult<'cf_accounts'>;
+type CfAccountInfoResponse = RpcResponse<'cf_account_info'>;
+type CfBoostPoolDetailsResponse = RpcResponse<'cf_boost_pool_details'>;
+type CfBoostPoolPendingFeesResponse = RpcResponse<'cf_boost_pool_pending_fees'>;
 type CfBoostPoolsDepthResponse = RpcResponse<'cf_boost_pools_depth'>;
 type CfEnvironmentResponse = RpcResponse<'cf_environment'>;
 type CfFundingEnvironmentResponse = RpcResponse<'cf_funding_environment'>;
 type CfIngressEgressEnvironmentResponse = RpcResponse<'cf_ingress_egress_environment'>;
+type CfPoolOrdersResponse = RpcResponse<'cf_pool_orders'>;
+type CfPoolPriceV2Response = RpcResponse<'cf_pool_price_v2'>;
+type CfPoolsEnvironmentResponse = RpcResponse<'cf_pools_environment'>;
 type CfSupportedAssetsResponse = RpcResponse<'cf_supported_assets'>;
 type CfSwappingEnvironmentResponse = RpcResponse<'cf_swapping_environment'>;
 type CfSwapRateResponse = RpcResponse<'cf_swap_rate'>;
 type CfSwapRateV2Response = RpcResponse<'cf_swap_rate_v2'>;
+type CfPoolDepthResponse = RpcResponse<'cf_pool_depth'>;
+type CfAccountsResponse = RpcResponse<'cf_accounts'>;
+type CfUnregisteredAccount = z.output<typeof unregistered>;
+type CfBrokerAccount = z.output<typeof broker>;
+type CfValidatorAccount = z.output<typeof validator>;
+type CfLiquidityProviderAccount = z.output<typeof liquidityProvider>;
 
-export { type CfBoostPoolsDepth, type CfBoostPoolsDepthResponse, type CfEnvironment, type CfEnvironmentResponse, type CfFundingEnvironment, type CfFundingEnvironmentResponse, type CfIngressEgressEnvironment, type CfIngressEgressEnvironmentResponse, type CfSupportedAssets, type CfSupportedAssetsResponse, type CfSwapRate, type CfSwapRateResponse, type CfSwapRateV2, type CfSwapRateV2Response, type CfSwappingEnvironment, type CfSwappingEnvironmentResponse, RpcResult };
+export { type CfAccountInfo, type CfAccountInfoResponse, type CfAccounts, type CfAccountsResponse, type CfBoostPoolDetails, type CfBoostPoolDetailsResponse, type CfBoostPoolPendingFees, type CfBoostPoolPendingFeesResponse, type CfBoostPoolsDepth, type CfBoostPoolsDepthResponse, type CfBrokerAccount, type CfEnvironment, type CfEnvironmentResponse, type CfFundingEnvironment, type CfFundingEnvironmentResponse, type CfIngressEgressEnvironment, type CfIngressEgressEnvironmentResponse, type CfLiquidityProviderAccount, type CfPoolDepth, type CfPoolDepthResponse, type CfPoolOrders, type CfPoolOrdersResponse, type CfPoolPriceV2, type CfPoolPriceV2Response, type CfPoolsEnvironment, type CfPoolsEnvironmentResponse, type CfSupportedAssets, type CfSupportedAssetsResponse, type CfSwapRate, type CfSwapRateResponse, type CfSwapRateV2, type CfSwapRateV2Response, type CfSwappingEnvironment, type CfSwappingEnvironmentResponse, type CfUnregisteredAccount, type CfValidatorAccount, RpcResult };

package/package.json

@@ -1,14 +1,7 @@
 {
   "name": "@chainflip/rpc",
-  "version": "1.6.4",
+  "version": "1.6.6",
   "type": "module",
-  "scripts": {
-    "clean": "rm -rf dist",
-    "prepublish": "pnpm test run && pnpm build",
-    "build": "pnpm clean && pnpm tsup",
-    "test": "vitest",
-    "coverage": "vitest run --coverage"
-  },
   "dependencies": {
     "@chainflip/utils": "^0.3.0",
     "zod": "^3.22.8"
@@ -48,5 +41,12 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "prepublish": "pnpm test run && pnpm build",
+    "build": "pnpm clean && pnpm tsup",
+    "test": "vitest",
+    "coverage": "vitest run --coverage"
   }
-}
+}

package/dist/index.js

@@ -1,9 +0,0 @@
-import { default as default2 } from "./HttpClient";
-import { default as default3 } from "./WsClient";
-export * from "./types";
-import * as constants from "./constants";
-export {
-  default2 as HttpClient,
-  default3 as WsClient,
-  constants
-};

package/dist/parsers.js

@@ -1,113 +0,0 @@
-import { isNotNullish } from "@chainflip/utils/guard";
-import { isHex } from "@chainflip/utils/string";
-import { z } from "zod";
-const hexString = z.string().refine(isHex, { message: "Invalid hex string" });
-const u256 = hexString.transform((value) => BigInt(value));
-const numberOrHex = z.union([z.number().transform((n) => BigInt(n)), u256]);
-const chainAssetMapFactory = (parser) => z.object({
-  Bitcoin: z.object({ BTC: parser }),
-  Ethereum: z.object({ ETH: parser, USDC: parser, FLIP: parser, USDT: parser }),
-  Polkadot: z.object({ DOT: parser }),
-  Arbitrum: z.object({ ETH: parser, USDC: parser })
-});
-const chainMapFactory = (parser) => z.object({ Bitcoin: parser, Ethereum: parser, Polkadot: parser, Arbitrum: parser });
-const rpcAssetSchema = z.union([
-  z.object({ chain: z.literal("Bitcoin"), asset: z.literal("BTC") }),
-  z.object({ chain: z.literal("Polkadot"), asset: z.literal("DOT") }),
-  z.object({ chain: z.literal("Ethereum"), asset: z.literal("FLIP") }),
-  z.object({ chain: z.literal("Ethereum"), asset: z.literal("ETH") }),
-  z.object({ chain: z.literal("Ethereum"), asset: z.literal("USDC") }),
-  z.object({ chain: z.literal("Ethereum"), asset: z.literal("USDT") }),
-  z.object({ chain: z.literal("Arbitrum"), asset: z.literal("ETH") }),
-  z.object({ chain: z.literal("Arbitrum"), asset: z.literal("USDC") })
-]);
-const rename = (mapping) => (obj) => Object.fromEntries(
-  Object.entries(obj).map(([key, value]) => [
-    key in mapping ? mapping[key] : key,
-    value
-  ])
-);
-const rpcBaseResponse = z.object({
-  id: z.union([z.string(), z.number()]),
-  jsonrpc: z.literal("2.0")
-});
-const nonNullish = z.any().refine(isNotNullish, { message: "Value must not be null or undefined" });
-const rpcSuccessResponse = rpcBaseResponse.extend({ result: nonNullish });
-const rpcErrorResponse = rpcBaseResponse.extend({
-  error: z.object({ code: z.number(), message: z.string() })
-});
-const rpcResponse = z.union([rpcSuccessResponse, rpcErrorResponse]);
-const cfSwapRate = z.object({
-  intermediary: numberOrHex.nullable(),
-  output: numberOrHex
-});
-const fee = z.intersection(rpcAssetSchema, z.object({ amount: numberOrHex }));
-const cfSwapRateV2 = z.object({
-  egress_fee: fee,
-  ingress_fee: fee,
-  intermediary: u256.nullable(),
-  network_fee: fee,
-  output: u256
-});
-const chainGetBlockHash = hexString;
-const stateGetMetadata = hexString;
-const stateGetRuntimeVersion = z.object({
-  specName: z.string(),
-  implName: z.string(),
-  authoringVersion: z.number(),
-  specVersion: z.number(),
-  implVersion: z.number(),
-  apis: z.array(z.tuple([hexString, z.number()])),
-  transactionVersion: z.number(),
-  stateVersion: z.number()
-});
-const cfIngressEgressEnvironment = z.object({
-  minimum_deposit_amounts: chainAssetMapFactory(numberOrHex),
-  ingress_fees: chainAssetMapFactory(numberOrHex.nullable()),
-  egress_fees: chainAssetMapFactory(numberOrHex.nullable()),
-  witness_safety_margins: chainMapFactory(z.number().nullable()),
-  egress_dust_limits: chainAssetMapFactory(numberOrHex),
-  channel_opening_fees: chainMapFactory(numberOrHex)
-}).transform(rename({ egress_dust_limits: "minimum_egress_amounts" }));
-const cfSwappingEnvironment = z.object({
-  maximum_swap_amounts: chainAssetMapFactory(numberOrHex.nullable()),
-  network_fee_hundredth_pips: z.number()
-});
-const cfFundingEnvironment = z.object({
-  redemption_tax: numberOrHex,
-  minimum_funding_amount: numberOrHex
-});
-const cfEnvironment = z.object({
-  ingress_egress: cfIngressEgressEnvironment,
-  swapping: cfSwappingEnvironment,
-  funding: cfFundingEnvironment
-});
-const cfBoostPoolsDepth = z.array(
-  z.intersection(rpcAssetSchema, z.object({ tier: z.number(), available_amount: u256 }))
-);
-const cfSupportedAsssets = z.array(rpcAssetSchema);
-const brokerRequestSwapDepositAddress = z.object({
-  address: z.string(),
-  issued_block: z.number(),
-  channel_id: z.number(),
-  source_chain_expiry_block: numberOrHex,
-  channel_opening_fee: u256
-});
-export {
-  brokerRequestSwapDepositAddress,
-  cfBoostPoolsDepth,
-  cfEnvironment,
-  cfFundingEnvironment,
-  cfIngressEgressEnvironment,
-  cfSupportedAsssets,
-  cfSwapRate,
-  cfSwapRateV2,
-  cfSwappingEnvironment,
-  chainGetBlockHash,
-  hexString,
-  numberOrHex,
-  rpcResponse,
-  stateGetMetadata,
-  stateGetRuntimeVersion,
-  u256
-};