@chainflip/redis 1.0.2-wbtc-dev.2 → 2.1.0-beta.0

package/dist/index.d.ts

@@ -1,336 +1,54 @@
-import { ChainflipChain, ChainflipAsset, AssetAndChain } from '@chainflip/utils/chainflip';
-import { z } from 'zod';
+import { AssethubBroadcast, BitcoinBroadcast, Broadcast, EthereumBroadcast, PendingDeposit } from "./parsers.js";
+import { ChainflipAsset, ChainflipChain } from "@chainflip/utils/chainflip";
 
-declare const depositSchema: z.ZodPipeline<z.ZodEffects<z.ZodString, unknown, string>, z.ZodObject<{
-    amount: z.ZodEffects<z.ZodUnion<[z.ZodNumber, z.ZodString, z.ZodEffects<z.ZodString, `0x${string}`, string>]>, bigint, string | number>;
-    asset: z.ZodEffects<z.ZodEffects<z.ZodObject<{
-        asset: z.ZodString;
-        chain: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        asset: string;
-        chain: string;
-    }, {
-        asset: string;
-        chain: string;
-    }>, AssetAndChain, {
-        asset: string;
-        chain: string;
-    }>, "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc", {
-        asset: string;
-        chain: string;
-    }>;
-    deposit_chain_block_height: z.ZodNumber;
-    deposit_details: z.ZodNullable<z.ZodUnion<[z.ZodEffects<z.ZodObject<{
-        tx_hashes: z.ZodArray<z.ZodEffects<z.ZodString, `0x${string}`, string>, "many">;
-    }, "strip", z.ZodTypeAny, {
-        tx_hashes: `0x${string}`[];
-    }, {
-        tx_hashes: string[];
-    }>, {
-        type: "EVM";
-        tx_hashes: `0x${string}`[];
-    }, {
-        tx_hashes: string[];
-    }>, z.ZodEffects<z.ZodObject<{
-        tx_id: z.ZodEffects<z.ZodEffects<z.ZodString, `0x${string}`, string>, string, string>;
-        vout: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        tx_id: string;
-        vout: number;
-    }, {
-        tx_id: string;
-        vout: number;
-    }>, {
-        type: "Bitcoin";
-        tx_id: string;
-        vout: number;
-    }, {
-        tx_id: string;
-        vout: number;
-    }>, z.ZodEffects<z.ZodObject<{
-        extrinsic_index: z.ZodNumber;
-    }, "strip", z.ZodTypeAny, {
-        extrinsic_index: number;
-    }, {
-        extrinsic_index: number;
-    }>, {
-        type: "Assethub";
-        extrinsic_index: number;
-    }, {
-        extrinsic_index: number;
-    }>]>>;
-}, "strip", z.ZodTypeAny, {
-    asset: "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc";
-    amount: bigint;
-    deposit_chain_block_height: number;
-    deposit_details: {
-        type: "Bitcoin";
-        tx_id: string;
-        vout: number;
-    } | {
-        type: "EVM";
-        tx_hashes: `0x${string}`[];
-    } | {
-        type: "Assethub";
-        extrinsic_index: number;
-    } | null;
-}, {
-    asset: {
-        asset: string;
-        chain: string;
-    };
-    amount: string | number;
-    deposit_chain_block_height: number;
-    deposit_details: {
-        tx_id: string;
-        vout: number;
-    } | {
-        tx_hashes: string[];
-    } | {
-        extrinsic_index: number;
-    } | null;
-}>>;
-type PendingDeposit = Omit<z.output<typeof depositSchema>, 'deposit_details'> & {
-    tx_refs: string[];
-};
-declare const broadcastParsers: {
-    readonly Ethereum: z.ZodObject<{
-        tx_out_id: z.ZodObject<{
-            signature: z.ZodObject<{
-                k_times_g_address: z.ZodArray<z.ZodNumber, "many">;
-                s: z.ZodArray<z.ZodNumber, "many">;
-            }, "strip", z.ZodTypeAny, {
-                k_times_g_address: number[];
-                s: number[];
-            }, {
-                k_times_g_address: number[];
-                s: number[];
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        }, {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        }>;
-        tx_ref: z.ZodEffects<z.ZodObject<{
-            hash: z.ZodEffects<z.ZodString, `0x${string}`, string>;
-        }, "strip", z.ZodTypeAny, {
-            hash: `0x${string}`;
-        }, {
-            hash: string;
-        }>, `0x${string}`, {
-            hash: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        tx_out_id: {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        };
-        tx_ref: `0x${string}`;
-    }, {
-        tx_out_id: {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        };
-        tx_ref: {
-            hash: string;
-        };
-    }>;
-    readonly Assethub: z.ZodObject<{
-        tx_out_id: z.ZodObject<{
-            signature: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            signature: string;
-        }, {
-            signature: string;
-        }>;
-        tx_ref: z.ZodEffects<z.ZodObject<{
-            transaction_id: z.ZodObject<{
-                block_number: z.ZodNumber;
-                extrinsic_index: z.ZodNumber;
-            }, "strip", z.ZodTypeAny, {
-                extrinsic_index: number;
-                block_number: number;
-            }, {
-                extrinsic_index: number;
-                block_number: number;
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            transaction_id: {
-                extrinsic_index: number;
-                block_number: number;
-            };
-        }, {
-            transaction_id: {
-                extrinsic_index: number;
-                block_number: number;
-            };
-        }>, string, {
-            transaction_id: {
-                extrinsic_index: number;
-                block_number: number;
-            };
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        tx_out_id: {
-            signature: string;
-        };
-        tx_ref: string;
-    }, {
-        tx_out_id: {
-            signature: string;
-        };
-        tx_ref: {
-            transaction_id: {
-                extrinsic_index: number;
-                block_number: number;
-            };
-        };
-    }>;
-    readonly Bitcoin: z.ZodObject<{
-        tx_out_id: z.ZodObject<{
-            hash: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            hash: string;
-        }, {
-            hash: string;
-        }>;
-        tx_ref: z.ZodEffects<z.ZodObject<{
-            hash: z.ZodEffects<z.ZodString, string, string>;
-        }, "strip", z.ZodTypeAny, {
-            hash: string;
-        }, {
-            hash: string;
-        }>, string, {
-            hash: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        tx_out_id: {
-            hash: string;
-        };
-        tx_ref: string;
-    }, {
-        tx_out_id: {
-            hash: string;
-        };
-        tx_ref: {
-            hash: string;
-        };
-    }>;
-    readonly Arbitrum: z.ZodObject<{
-        tx_out_id: z.ZodObject<{
-            signature: z.ZodObject<{
-                k_times_g_address: z.ZodArray<z.ZodNumber, "many">;
-                s: z.ZodArray<z.ZodNumber, "many">;
-            }, "strip", z.ZodTypeAny, {
-                k_times_g_address: number[];
-                s: number[];
-            }, {
-                k_times_g_address: number[];
-                s: number[];
-            }>;
-        }, "strip", z.ZodTypeAny, {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        }, {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        }>;
-        tx_ref: z.ZodEffects<z.ZodObject<{
-            hash: z.ZodEffects<z.ZodString, `0x${string}`, string>;
-        }, "strip", z.ZodTypeAny, {
-            hash: `0x${string}`;
-        }, {
-            hash: string;
-        }>, `0x${string}`, {
-            hash: string;
-        }>;
-    }, "strip", z.ZodTypeAny, {
-        tx_out_id: {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        };
-        tx_ref: `0x${string}`;
-    }, {
-        tx_out_id: {
-            signature: {
-                k_times_g_address: number[];
-                s: number[];
-            };
-        };
-        tx_ref: {
-            hash: string;
-        };
-    }>;
-};
-type ChainBroadcast<C extends Exclude<ChainflipChain, 'Solana' | 'Polkadot'>> = z.infer<(typeof broadcastParsers)[C]>;
-type EthereumBroadcast = ChainBroadcast<'Ethereum'>;
-type AssethubBroadcast = ChainBroadcast<'Assethub'>;
-type BitcoinBroadcast = ChainBroadcast<'Bitcoin'>;
-type Broadcast = ChainBroadcast<Exclude<ChainflipChain, 'Solana' | 'Polkadot'>>;
+//#region src/index.d.ts
 declare class RedisClient {
-    private client;
-    constructor(url: `redis://${string}` | `rediss://${string}`);
-    getBroadcast(chain: 'Ethereum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
-    getBroadcast(chain: 'Assethub', broadcastId: number | bigint): Promise<AssethubBroadcast | null>;
-    getBroadcast(chain: 'Bitcoin', broadcastId: number | bigint): Promise<BitcoinBroadcast | null>;
-    getBroadcast(chain: 'Arbitrum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
-    getBroadcast(chain: ChainflipChain, broadcastId: number | bigint): Promise<Broadcast | null>;
-    getDeposits(asset: ChainflipAsset, address: string): Promise<PendingDeposit[]>;
-    getMempoolTransaction(chain: 'Bitcoin', address: string): Promise<{
-        value: bigint;
-        confirmations: number;
-        tx_hash: string;
-        deposit_chain_block_height?: number | undefined;
-    } | null>;
-    getPendingVaultSwap(chain: ChainflipChain, txId: string): Promise<{
-        amount: bigint;
-        destinationAddress: string;
-        inputAsset: "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc";
-        outputAsset: "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc";
-        affiliateFees: {
-            account: string;
-            commissionBps: number;
-        }[];
-        depositChainBlockHeight?: number | null | undefined;
-        brokerFee?: {
-            account: string;
-            commissionBps: number;
-        } | undefined;
-        maxBoostFee?: number | undefined;
-        dcaParams?: {
-            chunkInterval: number;
-            numberOfChunks: number;
-        } | null | undefined;
-        refundParams?: {
-            minPrice: bigint;
-            retryDuration: number;
-            refundAddress: string;
-        } | null | undefined;
-        ccmDepositMetadata?: {
-            channelMetadata: {
-                message: string;
-                gasBudget: `0x${string}`;
-                ccmAdditionalData?: any;
-            };
-        } | null | undefined;
-    } | null>;
-    quit(): Promise<"OK">;
+  private client;
+  constructor(url: `redis://${string}` | `rediss://${string}`);
+  getBroadcast(chain: 'Ethereum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
+  getBroadcast(chain: 'Assethub', broadcastId: number | bigint): Promise<AssethubBroadcast | null>;
+  getBroadcast(chain: 'Bitcoin', broadcastId: number | bigint): Promise<BitcoinBroadcast | null>;
+  getBroadcast(chain: 'Arbitrum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
+  getBroadcast(chain: ChainflipChain, broadcastId: number | bigint): Promise<Broadcast | null>;
+  getDeposits(asset: ChainflipAsset, address: string): Promise<PendingDeposit[]>;
+  getMempoolTransaction(chain: 'Bitcoin', address: string): Promise<{
+    value: bigint;
+    confirmations: number;
+    tx_hash: string;
+    deposit_chain_block_height?: number | undefined;
+  } | null>;
+  getPendingVaultSwap(chain: ChainflipChain, txId: string): Promise<{
+    amount: bigint;
+    destinationAddress: string;
+    inputAsset: "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc";
+    outputAsset: "Usdc" | "Usdt" | "Wbtc" | "Flip" | "Eth" | "Dot" | "Btc" | "ArbUsdc" | "ArbUsdt" | "ArbEth" | "Sol" | "SolUsdc" | "SolUsdt" | "HubDot" | "HubUsdt" | "HubUsdc";
+    affiliateFees: {
+      account: string;
+      commissionBps: number;
+    }[];
+    depositChainBlockHeight?: number | null | undefined;
+    brokerFee?: {
+      account: string;
+      commissionBps: number;
+    } | undefined;
+    maxBoostFee?: number | undefined;
+    dcaParams?: {
+      chunkInterval: number;
+      numberOfChunks: number;
+    } | null | undefined;
+    refundParams?: {
+      minPrice: bigint;
+      retryDuration: number;
+      refundAddress: string;
+    } | null | undefined;
+    ccmDepositMetadata?: {
+      channelMetadata: {
+        message: string;
+        gasBudget: `0x${string}`;
+        ccmAdditionalData?: any;
+      };
+    } | null | undefined;
+  } | null>;
+  quit(): Promise<"OK">;
 }
-
-export { RedisClient as default };
+export = RedisClient;

package/dist/index.js

@@ -1,190 +1,65 @@
-import { reverseBytes } from '@chainflip/utils/bytes';
-import { isValidAssetAndChain, getInternalAsset, assetConstants } from '@chainflip/utils/chainflip';
-import { CHAINFLIP_SS58_PREFIX } from '@chainflip/utils/consts';
-import { hexEncodeNumber } from '@chainflip/utils/number';
-import * as ss58 from '@chainflip/utils/ss58';
-import { isHex } from '@chainflip/utils/string';
-import assert from 'assert';
-import Redis from 'ioredis';
-import { z } from 'zod';
+import { broadcastParsers, depositSchema, mempoolTransaction, vaultDepositSchema } from "./parsers.js";
+import { reverseBytes } from "@chainflip/utils/bytes";
+import { assetConstants } from "@chainflip/utils/chainflip";
+import * as ss58 from "@chainflip/utils/ss58";
+import { isHex } from "@chainflip/utils/string";
+import assert from "assert";
+import Redis from "ioredis";
 
-// src/index.ts
-
-// src/utils.ts
-var snakeToCamelCase = (str) => str.replace(/_(.)/g, (match, group) => group.toUpperCase());
-var transformKeysToCamelCase = (obj) => {
-  if (obj == null || typeof obj !== "object") return obj;
-  if (Array.isArray(obj)) return obj.map(transformKeysToCamelCase);
-  return Object.fromEntries(
-    Object.entries(obj).map(([key, value]) => [
-      snakeToCamelCase(key),
-      transformKeysToCamelCase(value)
-    ])
-  );
-};
-
-// src/index.ts
-var uncheckedAssetAndChain = z.object({
-  asset: z.string(),
-  chain: z.string()
-});
-var assetAndChain = uncheckedAssetAndChain.refine(
-  (value) => isValidAssetAndChain(value),
-  (value) => ({ message: `Invalid asset and chain : ${value.asset} on ${value.chain}` })
-).transform((value) => getInternalAsset(value));
-var numericString = z.string().regex(/^[0-9]+$/);
-var hexString = z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
-var u128 = z.union([z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
-var chainflipAddress = z.string().refine(
-  (address) => ss58.decode(address).ss58Format === CHAINFLIP_SS58_PREFIX,
-  (address) => ({ message: `${address} is not a valid Chainflip address` })
-);
-var jsonString = z.string().transform((value) => JSON.parse(value));
-var bitcoinDeposit = z.object({
-  tx_id: hexString.transform((value) => reverseBytes(value).slice(2)),
-  vout: z.number().int()
-}).transform((obj) => ({ ...obj, type: "Bitcoin" }));
-var evmDeposit = z.object({ tx_hashes: z.array(hexString) }).transform((obj) => ({ ...obj, type: "EVM" }));
-var assethubDeposit = z.object({ extrinsic_index: z.number() }).transform((obj) => ({ ...obj, type: "Assethub" }));
-var depositSchema = jsonString.pipe(
-  z.object({
-    amount: u128,
-    asset: assetAndChain,
-    deposit_chain_block_height: z.number(),
-    deposit_details: z.union([evmDeposit, bitcoinDeposit, assethubDeposit]).nullable()
-  })
-);
-var broadcastParsers = {
-  Ethereum: z.object({
-    tx_out_id: z.object({
-      signature: z.object({
-        k_times_g_address: z.array(z.number()),
-        s: z.array(z.number())
-      })
-    }),
-    tx_ref: z.object({
-      hash: hexString
-    }).transform(({ hash }) => hash)
-  }),
-  Assethub: z.object({
-    tx_out_id: z.object({ signature: z.string() }),
-    tx_ref: z.object({
-      transaction_id: z.object({
-        block_number: z.number(),
-        extrinsic_index: z.number()
-      })
-    }).transform(
-      ({ transaction_id }) => `${transaction_id.block_number}-${transaction_id.extrinsic_index}`
-    )
-  }),
-  Bitcoin: z.object({
-    tx_out_id: z.object({ hash: z.string() }),
-    tx_ref: z.object({
-      hash: z.string().transform((value) => value.startsWith("0x") ? value.slice(2) : value)
-    }).transform(({ hash }) => hash)
-  }),
-  Arbitrum: z.object({
-    tx_out_id: z.object({
-      signature: z.object({
-        k_times_g_address: z.array(z.number()),
-        s: z.array(z.number())
-      })
-    }),
-    tx_ref: z.object({
-      hash: hexString
-    }).transform(({ hash }) => hash)
-  })
-};
-var accountFee = z.object({
-  account: chainflipAddress,
-  bps: z.number()
-}).transform(({ account, bps }) => ({ account, commissionBps: bps }));
-var vaultDepositSchema = jsonString.pipe(
-  z.object({
-    amount: u128,
-    destination_address: z.string(),
-    input_asset: assetAndChain,
-    output_asset: assetAndChain,
-    deposit_chain_block_height: z.number().nullable().optional(),
-    affiliate_fees: z.array(accountFee),
-    broker_fee: accountFee.optional(),
-    max_boost_fee: z.number().optional(),
-    dca_params: z.object({
-      chunk_interval: z.number(),
-      number_of_chunks: z.number()
-    }).nullable().optional(),
-    refund_params: z.object({
-      min_price: u128,
-      retry_duration: z.number(),
-      refund_address: z.string()
-    }).nullable().optional(),
-    ccm_deposit_metadata: z.object({
-      channel_metadata: z.object({
-        ccm_additional_data: z.any(),
-        message: z.string(),
-        gas_budget: z.union([numericString, hexString]).transform((n) => hexEncodeNumber(BigInt(n)))
-      })
-    }).nullable().optional()
-  }).transform(transformKeysToCamelCase)
-);
-var mempoolTransaction = jsonString.pipe(
-  z.object({
-    confirmations: z.number(),
-    value: u128,
-    tx_hash: z.string(),
-    deposit_chain_block_height: z.number().optional()
-  })
-);
+//#region src/index.ts
 var RedisClient = class {
-  client;
-  constructor(url) {
-    this.client = new Redis(url);
-  }
-  async getBroadcast(chain, broadcastId) {
-    if (chain === "Solana" || chain === "Polkadot") return null;
-    const key = `broadcast:${chain}:${broadcastId}`;
-    const value = await this.client.get(key);
-    return value ? broadcastParsers[chain].parse(JSON.parse(value)) : null;
-  }
-  async getDeposits(asset, address) {
-    const { chain } = assetConstants[asset];
-    const parsedAddress = chain === "Assethub" ? ss58.toPublicKey(address) : address;
-    const key = `deposit:${chain}:${parsedAddress}`;
-    const deposits = await this.client.lrange(key, 0, -1);
-    return deposits.map((depositString) => {
-      const parsedDeposit = depositSchema.parse(depositString);
-      const { deposit_details, ...deposit } = parsedDeposit;
-      switch (deposit_details?.type) {
-        case "EVM":
-          return { ...deposit, tx_refs: deposit_details.tx_hashes };
-        case "Bitcoin":
-          return { ...deposit, tx_refs: [deposit_details.tx_id] };
-        case "Assethub":
-          return {
-            ...deposit,
-            tx_refs: [`${deposit.deposit_chain_block_height}-${deposit_details.extrinsic_index}`]
-          };
-        default:
-          assert(deposit_details === null, "Invalid deposit details");
-          return { ...deposit, tx_refs: [] };
-      }
-    }).filter((deposit) => deposit.asset === asset).sort((a, b) => a.deposit_chain_block_height - b.deposit_chain_block_height);
-  }
-  async getMempoolTransaction(chain, address) {
-    const key = `mempool:${chain}:${address}`;
-    const value = await this.client.get(key);
-    return value ? mempoolTransaction.parse(value) : null;
-  }
-  async getPendingVaultSwap(chain, txId) {
-    const unavailableChains = ["Solana", "Assethub"];
-    if (unavailableChains.includes(chain)) return null;
-    const redisTxId = chain === "Bitcoin" && isHex(`0x${txId}`) ? reverseBytes(`0x${txId}`) : txId;
-    const value = await this.client.get(`vault_deposit:${chain}:${redisTxId}`);
-    return value ? vaultDepositSchema.parse(value) : null;
-  }
-  quit() {
-    return this.client.quit();
-  }
+	client;
+	constructor(url) {
+		this.client = new Redis(url);
+	}
+	async getBroadcast(chain, broadcastId) {
+		if (chain === "Solana" || chain === "Polkadot") return null;
+		const key = `broadcast:${chain}:${broadcastId}`;
+		const value = await this.client.get(key);
+		return value ? broadcastParsers[chain].parse(JSON.parse(value)) : null;
+	}
+	async getDeposits(asset, address) {
+		const { chain } = assetConstants[asset];
+		const key = `deposit:${chain}:${chain === "Assethub" ? ss58.toPublicKey(address) : address}`;
+		return (await this.client.lrange(key, 0, -1)).map((depositString) => {
+			const { deposit_details, ...deposit } = depositSchema.parse(depositString);
+			switch (deposit_details?.type) {
+				case "EVM": return {
+					...deposit,
+					tx_refs: deposit_details.tx_hashes
+				};
+				case "Bitcoin": return {
+					...deposit,
+					tx_refs: [deposit_details.tx_id]
+				};
+				case "Assethub": return {
+					...deposit,
+					tx_refs: [`${deposit.deposit_chain_block_height}-${deposit_details.extrinsic_index}`]
+				};
+				default:
+					assert(deposit_details === null, "Invalid deposit details");
+					return {
+						...deposit,
+						tx_refs: []
+					};
+			}
+		}).filter((deposit) => deposit.asset === asset).sort((a, b) => a.deposit_chain_block_height - b.deposit_chain_block_height);
+	}
+	async getMempoolTransaction(chain, address) {
+		const key = `mempool:${chain}:${address}`;
+		const value = await this.client.get(key);
+		return value ? mempoolTransaction.parse(value) : null;
+	}
+	async getPendingVaultSwap(chain, txId) {
+		if (["Solana", "Assethub"].includes(chain)) return null;
+		const redisTxId = chain === "Bitcoin" && isHex(`0x${txId}`) ? reverseBytes(`0x${txId}`) : txId;
+		const value = await this.client.get(`vault_deposit:${chain}:${redisTxId}`);
+		return value ? vaultDepositSchema.parse(value) : null;
+	}
+	quit() {
+		return this.client.quit();
+	}
 };
 
-export { RedisClient as default };
+//#endregion
+export { RedisClient as default };