@chainflip/rpc 1.6.4 → 1.6.5

package/dist/{common.js → common.mjs}

@@ -1,32 +1,47 @@
+// src/common.ts
 import {
+  cfBoostPoolDetails,
+  cfBoostPoolPendingFees,
   brokerRequestSwapDepositAddress,
+  cfAccountInfo,
   cfBoostPoolsDepth,
   cfEnvironment,
   cfFundingEnvironment,
   cfIngressEgressEnvironment,
+  cfPoolOrders,
+  cfPoolPriceV2,
+  cfPoolsEnvironment,
   cfSupportedAsssets,
   cfSwapRate,
   cfSwapRateV2,
   cfSwappingEnvironment,
   chainGetBlockHash,
   stateGetMetadata,
-  stateGetRuntimeVersion
-} from "./parsers";
-const rpcResult = {
+  stateGetRuntimeVersion,
+  cfPoolDepth
+} from "./parsers.mjs";
+import { rpcResponse as rpcResponse2 } from "./parsers.mjs";
+var rpcResult = {
   broker_requestSwapDepositAddress: brokerRequestSwapDepositAddress,
+  cf_account_info: cfAccountInfo,
+  cf_pool_depth: cfPoolDepth,
   cf_boost_pools_depth: cfBoostPoolsDepth,
   cf_environment: cfEnvironment,
   cf_funding_environment: cfFundingEnvironment,
   cf_ingress_egress_environment: cfIngressEgressEnvironment,
+  cf_pool_orders: cfPoolOrders,
+  cf_pool_price_v2: cfPoolPriceV2,
+  cf_pools_environment: cfPoolsEnvironment,
   cf_supported_assets: cfSupportedAsssets,
   cf_swap_rate: cfSwapRate,
   cf_swap_rate_v2: cfSwapRateV2,
   cf_swapping_environment: cfSwappingEnvironment,
   chain_getBlockHash: chainGetBlockHash,
+  cf_boost_pool_details: cfBoostPoolDetails,
+  cf_boost_pool_pending_fees: cfBoostPoolPendingFees,
   state_getMetadata: stateGetMetadata,
   state_getRuntimeVersion: stateGetRuntimeVersion
 };
-import { rpcResponse as rpcResponse2 } from "./parsers";
 export {
   rpcResponse2 as rpcResponse,
   rpcResult

package/dist/constants.cjs

@@ -1,5 +1,6 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});const PUBLIC_RPC_ENDPOINTS = {
-  mainnet: "https://mainnet-archive.chainflip.io",
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});// src/constants.ts
+var PUBLIC_RPC_ENDPOINTS = {
+  mainnet: "https://rpc.mainnet.chainflip.io",
   perseverance: "https://archive.perseverance.chainflip.io",
   sisyphos: "https://archive.sisyphos.chainflip.io",
   backspin: "https://backspin-rpc.staging"

package/dist/{constants.js → constants.mjs}

@@ -1,5 +1,6 @@
-const PUBLIC_RPC_ENDPOINTS = {
-  mainnet: "https://mainnet-archive.chainflip.io",
+// src/constants.ts
+var PUBLIC_RPC_ENDPOINTS = {
+  mainnet: "https://rpc.mainnet.chainflip.io",
   perseverance: "https://archive.perseverance.chainflip.io",
   sisyphos: "https://archive.sisyphos.chainflip.io",
   backspin: "https://backspin-rpc.staging"

package/dist/index.cjs

@@ -1,9 +1,10 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); }var _HttpClient = require('./HttpClient'); var _HttpClient2 = _interopRequireDefault(_HttpClient);
-var _WsClient = require('./WsClient'); var _WsClient2 = _interopRequireDefault(_WsClient);
-var _types = require('./types'); _createStarExport(_types);
-var _constants = require('./constants'); var constants = _interopRequireWildcard(_constants);
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, configurable: true, get: () => obj[key]}); }); }// src/index.ts
+var _HttpClientcjs = require('./HttpClient.cjs'); var _HttpClientcjs2 = _interopRequireDefault(_HttpClientcjs);
+var _WsClientcjs = require('./WsClient.cjs'); var _WsClientcjs2 = _interopRequireDefault(_WsClientcjs);
+var _typescjs = require('./types.cjs'); _createStarExport(_typescjs);
+var _constantscjs = require('./constants.cjs'); var constants = _interopRequireWildcard(_constantscjs);
 
 
 
 
-exports.HttpClient = _HttpClient2.default; exports.WsClient = _WsClient2.default; exports.constants = constants;
+exports.HttpClient = _HttpClientcjs2.default; exports.WsClient = _WsClientcjs2.default; exports.constants = constants;

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 export { default as HttpClient } from './HttpClient.cjs';
 export { default as WsClient } from './WsClient.cjs';
-export { CfBoostPoolsDepth, CfBoostPoolsDepthResponse, CfEnvironment, CfEnvironmentResponse, CfFundingEnvironment, CfFundingEnvironmentResponse, CfIngressEgressEnvironment, CfIngressEgressEnvironmentResponse, CfSupportedAssets, CfSupportedAssetsResponse, CfSwapRate, CfSwapRateResponse, CfSwapRateV2, CfSwapRateV2Response, CfSwappingEnvironment, CfSwappingEnvironmentResponse } from './types.cjs';
+export { CfAccountInfo, CfAccountInfoResponse, CfBoostPoolDetails, CfBoostPoolDetailsResponse, CfBoostPoolPendingFees, CfBoostPoolPendingFeesResponse, CfBoostPoolsDepth, CfBoostPoolsDepthResponse, CfBrokerAccount, CfEnvironment, CfEnvironmentResponse, CfFundingEnvironment, CfFundingEnvironmentResponse, CfIngressEgressEnvironment, CfIngressEgressEnvironmentResponse, CfLiquidityProviderAccount, CfPoolDepth, CfPoolDepthResponse, CfPoolOrders, CfPoolOrdersResponse, CfPoolPriceV2, CfPoolPriceV2Response, CfPoolsEnvironment, CfPoolsEnvironmentResponse, CfSupportedAssets, CfSupportedAssetsResponse, CfSwapRate, CfSwapRateResponse, CfSwapRateV2, CfSwapRateV2Response, CfSwappingEnvironment, CfSwappingEnvironmentResponse, CfUnregisteredAccount, CfValidatorAccount } from './types.cjs';
 export { c as constants } from './constants-jLrn-AnI.cjs';
+export { RpcLimitOrder, RpcRangeOrder } from './parsers.cjs';
 export { RpcMethod, RpcRequest as RpcParams, RpcResult } from './common.cjs';
 import './Client.cjs';
 import 'zod';
-import './parsers.cjs';
 import '@chainflip/utils/types';

package/dist/index.d.ts

@@ -1,9 +1,9 @@
 export { default as HttpClient } from './HttpClient.js';
 export { default as WsClient } from './WsClient.js';
-export { CfBoostPoolsDepth, CfBoostPoolsDepthResponse, CfEnvironment, CfEnvironmentResponse, CfFundingEnvironment, CfFundingEnvironmentResponse, CfIngressEgressEnvironment, CfIngressEgressEnvironmentResponse, CfSupportedAssets, CfSupportedAssetsResponse, CfSwapRate, CfSwapRateResponse, CfSwapRateV2, CfSwapRateV2Response, CfSwappingEnvironment, CfSwappingEnvironmentResponse } from './types.js';
+export { CfAccountInfo, CfAccountInfoResponse, CfBoostPoolDetails, CfBoostPoolDetailsResponse, CfBoostPoolPendingFees, CfBoostPoolPendingFeesResponse, CfBoostPoolsDepth, CfBoostPoolsDepthResponse, CfBrokerAccount, CfEnvironment, CfEnvironmentResponse, CfFundingEnvironment, CfFundingEnvironmentResponse, CfIngressEgressEnvironment, CfIngressEgressEnvironmentResponse, CfLiquidityProviderAccount, CfPoolDepth, CfPoolDepthResponse, CfPoolOrders, CfPoolOrdersResponse, CfPoolPriceV2, CfPoolPriceV2Response, CfPoolsEnvironment, CfPoolsEnvironmentResponse, CfSupportedAssets, CfSupportedAssetsResponse, CfSwapRate, CfSwapRateResponse, CfSwapRateV2, CfSwapRateV2Response, CfSwappingEnvironment, CfSwappingEnvironmentResponse, CfUnregisteredAccount, CfValidatorAccount } from './types.js';
 export { c as constants } from './constants-jLrn-AnI.js';
+export { RpcLimitOrder, RpcRangeOrder } from './parsers.js';
 export { RpcMethod, RpcRequest as RpcParams, RpcResult } from './common.js';
 import './Client.js';
 import 'zod';
-import './parsers.js';
 import '@chainflip/utils/types';

package/dist/index.mjs

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

package/dist/parsers.cjs

@@ -1,17 +1,32 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});var _guard = require('@chainflip/utils/guard');
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/parsers.ts
+var _guard = require('@chainflip/utils/guard');
 var _string = require('@chainflip/utils/string');
 var _zod = require('zod');
-const hexString = _zod.z.string().refine(_string.isHex, { message: "Invalid hex string" });
-const u256 = hexString.transform((value) => BigInt(value));
-const numberOrHex = _zod.z.union([_zod.z.number().transform((n) => BigInt(n)), u256]);
-const chainAssetMapFactory = (parser) => _zod.z.object({
+var hexString = _zod.z.string().refine(_string.isHex, { message: "Invalid hex string" });
+var u256 = hexString.transform((value) => BigInt(value));
+var numberOrHex = _zod.z.union([_zod.z.number().transform((n) => BigInt(n)), u256]);
+var chainAssetMapFactory = (parser, defaultValue) => _zod.z.object({
   Bitcoin: _zod.z.object({ BTC: parser }),
   Ethereum: _zod.z.object({ ETH: parser, USDC: parser, FLIP: parser, USDT: parser }),
   Polkadot: _zod.z.object({ DOT: parser }),
-  Arbitrum: _zod.z.object({ ETH: parser, USDC: parser })
+  Arbitrum: _zod.z.object({ ETH: parser, USDC: parser }),
+  Solana: _zod.z.object({ SOL: parser.default(defaultValue), USDC: parser.default(defaultValue) }).default({ SOL: defaultValue, USDC: defaultValue })
 });
-const chainMapFactory = (parser) => _zod.z.object({ Bitcoin: parser, Ethereum: parser, Polkadot: parser, Arbitrum: parser });
-const rpcAssetSchema = _zod.z.union([
+var chainBaseAssetMapFactory = (parser, defaultValue) => _zod.z.object({
+  Bitcoin: _zod.z.object({ BTC: parser }),
+  Ethereum: _zod.z.object({ ETH: parser, FLIP: parser, USDT: parser }),
+  Polkadot: _zod.z.object({ DOT: parser }),
+  Arbitrum: _zod.z.object({ ETH: parser, USDC: parser }),
+  Solana: _zod.z.object({ SOL: parser.default(defaultValue), USDC: parser.default(defaultValue) }).default({ SOL: defaultValue, USDC: defaultValue })
+});
+var chainMapFactory = (parser, defaultValue) => _zod.z.object({
+  Bitcoin: parser,
+  Ethereum: parser,
+  Polkadot: parser,
+  Arbitrum: parser,
+  Solana: parser.default(defaultValue)
+});
+var rpcAssetSchema = _zod.z.union([
   _zod.z.object({ chain: _zod.z.literal("Bitcoin"), asset: _zod.z.literal("BTC") }),
   _zod.z.object({ chain: _zod.z.literal("Polkadot"), asset: _zod.z.literal("DOT") }),
   _zod.z.object({ chain: _zod.z.literal("Ethereum"), asset: _zod.z.literal("FLIP") }),
@@ -19,39 +34,41 @@ const rpcAssetSchema = _zod.z.union([
   _zod.z.object({ chain: _zod.z.literal("Ethereum"), asset: _zod.z.literal("USDC") }),
   _zod.z.object({ chain: _zod.z.literal("Ethereum"), asset: _zod.z.literal("USDT") }),
   _zod.z.object({ chain: _zod.z.literal("Arbitrum"), asset: _zod.z.literal("ETH") }),
-  _zod.z.object({ chain: _zod.z.literal("Arbitrum"), asset: _zod.z.literal("USDC") })
+  _zod.z.object({ chain: _zod.z.literal("Arbitrum"), asset: _zod.z.literal("USDC") }),
+  _zod.z.object({ chain: _zod.z.literal("Solana"), asset: _zod.z.literal("SOL") }),
+  _zod.z.object({ chain: _zod.z.literal("Solana"), asset: _zod.z.literal("USDC") })
 ]);
-const rename = (mapping) => (obj) => Object.fromEntries(
+var rename = (mapping) => (obj) => Object.fromEntries(
   Object.entries(obj).map(([key, value]) => [
     key in mapping ? mapping[key] : key,
     value
   ])
 );
-const rpcBaseResponse = _zod.z.object({
+var rpcBaseResponse = _zod.z.object({
   id: _zod.z.union([_zod.z.string(), _zod.z.number()]),
   jsonrpc: _zod.z.literal("2.0")
 });
-const nonNullish = _zod.z.any().refine(_guard.isNotNullish, { message: "Value must not be null or undefined" });
-const rpcSuccessResponse = rpcBaseResponse.extend({ result: nonNullish });
-const rpcErrorResponse = rpcBaseResponse.extend({
+var nonNullish = _zod.z.any().refine(_guard.isNotNullish, { message: "Value must not be null or undefined" });
+var rpcSuccessResponse = rpcBaseResponse.extend({ result: nonNullish });
+var rpcErrorResponse = rpcBaseResponse.extend({
   error: _zod.z.object({ code: _zod.z.number(), message: _zod.z.string() })
 });
-const rpcResponse = _zod.z.union([rpcSuccessResponse, rpcErrorResponse]);
-const cfSwapRate = _zod.z.object({
+var rpcResponse = _zod.z.union([rpcSuccessResponse, rpcErrorResponse]);
+var cfSwapRate = _zod.z.object({
   intermediary: numberOrHex.nullable(),
   output: numberOrHex
 });
-const fee = _zod.z.intersection(rpcAssetSchema, _zod.z.object({ amount: numberOrHex }));
-const cfSwapRateV2 = _zod.z.object({
+var fee = _zod.z.intersection(rpcAssetSchema, _zod.z.object({ amount: numberOrHex }));
+var cfSwapRateV2 = _zod.z.object({
   egress_fee: fee,
   ingress_fee: fee,
   intermediary: u256.nullable(),
   network_fee: fee,
   output: u256
 });
-const chainGetBlockHash = hexString;
-const stateGetMetadata = hexString;
-const stateGetRuntimeVersion = _zod.z.object({
+var chainGetBlockHash = hexString;
+var stateGetMetadata = hexString;
+var stateGetRuntimeVersion = _zod.z.object({
   specName: _zod.z.string(),
   implName: _zod.z.string(),
   authoringVersion: _zod.z.number(),
@@ -61,38 +78,209 @@ const stateGetRuntimeVersion = _zod.z.object({
   transactionVersion: _zod.z.number(),
   stateVersion: _zod.z.number()
 });
-const cfIngressEgressEnvironment = _zod.z.object({
-  minimum_deposit_amounts: chainAssetMapFactory(numberOrHex),
-  ingress_fees: chainAssetMapFactory(numberOrHex.nullable()),
-  egress_fees: chainAssetMapFactory(numberOrHex.nullable()),
-  witness_safety_margins: chainMapFactory(_zod.z.number().nullable()),
-  egress_dust_limits: chainAssetMapFactory(numberOrHex),
-  channel_opening_fees: chainMapFactory(numberOrHex)
+var cfIngressEgressEnvironment = _zod.z.object({
+  minimum_deposit_amounts: chainAssetMapFactory(numberOrHex, 0),
+  ingress_fees: chainAssetMapFactory(numberOrHex.nullable(), null),
+  egress_fees: chainAssetMapFactory(numberOrHex.nullable(), null),
+  witness_safety_margins: chainMapFactory(_zod.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(_zod.z.number(), 0).optional().default({ Arbitrum: 0, Bitcoin: 0, Ethereum: 0, Polkadot: 0, Solana: 0 })
 }).transform(rename({ egress_dust_limits: "minimum_egress_amounts" }));
-const cfSwappingEnvironment = _zod.z.object({
-  maximum_swap_amounts: chainAssetMapFactory(numberOrHex.nullable()),
+var cfSwappingEnvironment = _zod.z.object({
+  maximum_swap_amounts: chainAssetMapFactory(numberOrHex.nullable(), null),
   network_fee_hundredth_pips: _zod.z.number()
 });
-const cfFundingEnvironment = _zod.z.object({
+var cfFundingEnvironment = _zod.z.object({
   redemption_tax: numberOrHex,
   minimum_funding_amount: numberOrHex
 });
-const cfEnvironment = _zod.z.object({
+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 = _zod.z.object({
+  fees: chainBaseAssetMapFactory(
+    _zod.z.object({
+      limit_order_fee_hundredth_pips: _zod.z.number(),
+      range_order_fee_hundredth_pips: _zod.z.number(),
+      range_order_total_fees_earned: _zod.z.object({ base: u256, quote: u256 }),
+      limit_order_total_fees_earned: _zod.z.object({ base: u256, quote: u256 }),
+      range_total_swap_inputs: _zod.z.object({ base: u256, quote: u256 }),
+      limit_total_swap_inputs: _zod.z.object({ base: u256, quote: u256 }),
+      quote_asset: _zod.z.object({ chain: _zod.z.literal("Ethereum"), asset: _zod.z.literal("USDC") })
+    }).nullable().transform((info) => _nullishCoalesce(info, () => ( structuredClone(defaultFeeInfo)))),
+    structuredClone(defaultFeeInfo)
+  )
+});
+var cfEnvironment = _zod.z.object({
   ingress_egress: cfIngressEgressEnvironment,
   swapping: cfSwappingEnvironment,
-  funding: cfFundingEnvironment
+  funding: cfFundingEnvironment,
+  pools: cfPoolsEnvironment
 });
-const cfBoostPoolsDepth = _zod.z.array(
+var cfBoostPoolsDepth = _zod.z.array(
   _zod.z.intersection(rpcAssetSchema, _zod.z.object({ tier: _zod.z.number(), available_amount: u256 }))
 );
-const cfSupportedAsssets = _zod.z.array(rpcAssetSchema);
-const brokerRequestSwapDepositAddress = _zod.z.object({
+var orderInfoSchema = _zod.z.object({
+  depth: numberOrHex,
+  price: numberOrHex.nullable()
+});
+var assetInfoSchema = _zod.z.object({
+  limit_orders: orderInfoSchema,
+  range_orders: orderInfoSchema
+});
+var cfPoolDepth = _zod.z.object({
+  asks: assetInfoSchema,
+  bids: assetInfoSchema
+}).nullable();
+var cfSupportedAsssets = _zod.z.array(_zod.z.object({ chain: _zod.z.string(), asset: _zod.z.string() })).transform(
+  (assets) => assets.filter((asset) => rpcAssetSchema.safeParse(asset).success)
+);
+var brokerRequestSwapDepositAddress = _zod.z.object({
   address: _zod.z.string(),
   issued_block: _zod.z.number(),
   channel_id: _zod.z.number(),
   source_chain_expiry_block: numberOrHex,
   channel_opening_fee: u256
 });
+var unregistered = _zod.z.object({
+  role: _zod.z.literal("unregistered"),
+  flip_balance: numberOrHex
+});
+var broker = _zod.z.object({
+  role: _zod.z.literal("broker"),
+  flip_balance: numberOrHex,
+  earned_fees: chainAssetMapFactory(numberOrHex, 0)
+});
+var boostBalances = _zod.z.array(
+  _zod.z.object({
+    fee_tier: _zod.z.number(),
+    total_balance: u256,
+    available_balance: u256,
+    in_use_balance: u256,
+    is_withdrawing: _zod.z.boolean()
+  })
+);
+var liquidityProvider = _zod.z.object({
+  role: _zod.z.literal("liquidity_provider"),
+  balances: chainAssetMapFactory(numberOrHex, "0x0"),
+  refund_addresses: chainMapFactory(_zod.z.string().nullable(), null),
+  flip_balance: numberOrHex,
+  earned_fees: chainAssetMapFactory(numberOrHex, 0),
+  boost_balances: chainAssetMapFactory(boostBalances, [])
+});
+var validator = _zod.z.object({
+  role: _zod.z.literal("validator"),
+  flip_balance: numberOrHex,
+  bond: numberOrHex,
+  last_heartbeat: _zod.z.number(),
+  reputation_points: _zod.z.number(),
+  keyholder_epochs: _zod.z.array(_zod.z.number()),
+  is_current_authority: _zod.z.boolean(),
+  is_current_backup: _zod.z.boolean(),
+  is_qualified: _zod.z.boolean(),
+  is_online: _zod.z.boolean(),
+  is_bidding: _zod.z.boolean(),
+  bound_redeem_address: hexString.nullable(),
+  apy_bp: _zod.z.number().nullable(),
+  restricted_balances: _zod.z.record(hexString, numberOrHex)
+});
+var cfAccountInfo = _zod.z.union([unregistered, broker, liquidityProvider, validator]);
+var cfPoolPriceV2 = _zod.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 = _zod.z.object({
+  id: orderId,
+  tick: _zod.z.number(),
+  sell_amount: numberOrHex,
+  fees_earned: numberOrHex,
+  original_sell_amount: numberOrHex,
+  lp: _zod.z.string()
+});
+var ask = limitOrder.transform((order) => ({
+  ...order,
+  type: "ask"
+}));
+var bid = limitOrder.transform((order) => ({
+  ...order,
+  type: "bid"
+}));
+var rangeOrder = _zod.z.object({
+  id: orderId,
+  range: _zod.z.object({ start: _zod.z.number(), end: _zod.z.number() }),
+  liquidity: numberOrHex,
+  fees_earned: _zod.z.object({ base: numberOrHex, quote: numberOrHex }),
+  lp: _zod.z.string()
+}).transform((order) => ({ ...order, type: "range" }));
+var cfPoolOrders = _zod.z.object({
+  limit_orders: _zod.z.object({
+    asks: _zod.z.array(ask),
+    bids: _zod.z.array(bid)
+  }),
+  range_orders: _zod.z.array(rangeOrder)
+});
+var boostPoolAmount = _zod.z.object({
+  account_id: _zod.z.string(),
+  amount: u256
+});
+var cfBoostPoolDetails = _zod.z.array(
+  _zod.z.intersection(
+    rpcAssetSchema,
+    _zod.z.object({
+      fee_tier: _zod.z.number(),
+      available_amounts: _zod.z.array(boostPoolAmount),
+      deposits_pending_finalization: _zod.z.array(
+        _zod.z.object({
+          deposit_id: _zod.z.number().transform(BigInt),
+          owed_amounts: _zod.z.array(boostPoolAmount)
+        })
+      ),
+      pending_withdrawals: _zod.z.array(
+        _zod.z.object({
+          account_id: _zod.z.string(),
+          pending_deposits: _zod.z.array(_zod.z.bigint())
+        })
+      )
+    })
+  )
+);
+var cfBoostPoolPendingFees = _zod.z.array(
+  _zod.z.intersection(
+    rpcAssetSchema,
+    _zod.z.object({
+      fee_tier: _zod.z.number(),
+      pending_fees: _zod.z.array(
+        _zod.z.object({
+          deposit_id: _zod.z.number().transform(BigInt),
+          fees: _zod.z.array(boostPoolAmount)
+        })
+      )
+    })
+  )
+);
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -110,4 +298,4 @@ const brokerRequestSwapDepositAddress = _zod.z.object({
 
 
 
-exports.brokerRequestSwapDepositAddress = brokerRequestSwapDepositAddress; exports.cfBoostPoolsDepth = cfBoostPoolsDepth; exports.cfEnvironment = cfEnvironment; exports.cfFundingEnvironment = cfFundingEnvironment; exports.cfIngressEgressEnvironment = cfIngressEgressEnvironment; exports.cfSupportedAsssets = cfSupportedAsssets; exports.cfSwapRate = cfSwapRate; exports.cfSwapRateV2 = cfSwapRateV2; exports.cfSwappingEnvironment = cfSwappingEnvironment; exports.chainGetBlockHash = chainGetBlockHash; exports.hexString = hexString; exports.numberOrHex = numberOrHex; exports.rpcResponse = rpcResponse; exports.stateGetMetadata = stateGetMetadata; exports.stateGetRuntimeVersion = stateGetRuntimeVersion; exports.u256 = u256;
+exports.broker = broker; exports.brokerRequestSwapDepositAddress = brokerRequestSwapDepositAddress; exports.cfAccountInfo = cfAccountInfo; exports.cfBoostPoolDetails = cfBoostPoolDetails; exports.cfBoostPoolPendingFees = cfBoostPoolPendingFees; exports.cfBoostPoolsDepth = cfBoostPoolsDepth; exports.cfEnvironment = cfEnvironment; exports.cfFundingEnvironment = cfFundingEnvironment; exports.cfIngressEgressEnvironment = cfIngressEgressEnvironment; exports.cfPoolDepth = cfPoolDepth; exports.cfPoolOrders = cfPoolOrders; exports.cfPoolPriceV2 = cfPoolPriceV2; exports.cfPoolsEnvironment = cfPoolsEnvironment; exports.cfSupportedAsssets = cfSupportedAsssets; exports.cfSwapRate = cfSwapRate; exports.cfSwapRateV2 = cfSwapRateV2; exports.cfSwappingEnvironment = cfSwappingEnvironment; exports.chainGetBlockHash = chainGetBlockHash; exports.hexString = hexString; exports.liquidityProvider = liquidityProvider; exports.numberOrHex = numberOrHex; exports.rpcResponse = rpcResponse; exports.stateGetMetadata = stateGetMetadata; exports.stateGetRuntimeVersion = stateGetRuntimeVersion; exports.u256 = u256; exports.unregistered = unregistered; exports.validator = validator;