@chainflip/redis 1.0.0

package/README.md

@@ -0,0 +1 @@
+## @chainflip/redis

package/dist/index.cjs

@@ -0,0 +1,227 @@
+'use strict';
+
+var bytes = require('@chainflip/utils/bytes');
+var chainflip = require('@chainflip/utils/chainflip');
+var consts = require('@chainflip/utils/consts');
+var number = require('@chainflip/utils/number');
+var ss58 = require('@chainflip/utils/ss58');
+var string = require('@chainflip/utils/string');
+var assert = require('assert');
+var Redis = require('ioredis');
+var zod = require('zod');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var ss58__namespace = /*#__PURE__*/_interopNamespace(ss58);
+var assert__default = /*#__PURE__*/_interopDefault(assert);
+var Redis__default = /*#__PURE__*/_interopDefault(Redis);
+
+// 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 = zod.z.object({
+  asset: zod.z.string(),
+  chain: zod.z.string()
+});
+var assetAndChain = uncheckedAssetAndChain.refine(
+  (value) => chainflip.isValidAssetAndChain(value),
+  { message: "Invalid asset and chain" }
+).transform((value) => chainflip.getInternalAsset(value));
+var numericString = zod.z.string().regex(/^[0-9]+$/);
+var hexString = zod.z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
+var u128 = zod.z.union([zod.z.number(), numericString, hexString]).transform((arg) => BigInt(arg));
+var chainflipAddress = zod.z.string().refine(
+  (address) => ss58__namespace.decode(address).ss58Format === consts.CHAINFLIP_SS58_PREFIX,
+  (address) => ({ message: `${address} is not a valid Chainflip address` })
+);
+var jsonString = zod.z.string().transform((value) => JSON.parse(value));
+var bitcoinDeposit = zod.z.object({
+  tx_id: hexString.transform((value) => bytes.reverseBytes(value).slice(2)),
+  vout: zod.z.number().int()
+}).transform((obj) => ({ ...obj, type: "Bitcoin" }));
+var evmDeposit = zod.z.object({ tx_hashes: zod.z.array(hexString) }).transform((obj) => ({ ...obj, type: "EVM" }));
+var polkadotDeposit = zod.z.object({ extrinsic_index: zod.z.number() }).transform((obj) => ({ ...obj, type: "Polkadot" }));
+var depositSchema = jsonString.pipe(
+  zod.z.object({
+    amount: u128,
+    asset: assetAndChain,
+    deposit_chain_block_height: zod.z.number(),
+    deposit_details: zod.z.union([evmDeposit, bitcoinDeposit, polkadotDeposit]).nullable()
+  })
+);
+var broadcastParsers = {
+  Ethereum: zod.z.object({
+    tx_out_id: zod.z.object({
+      signature: zod.z.object({
+        k_times_g_address: zod.z.array(zod.z.number()),
+        s: zod.z.array(zod.z.number())
+      })
+    }),
+    tx_ref: zod.z.object({
+      hash: hexString
+    }).transform(({ hash }) => hash)
+  }),
+  Polkadot: zod.z.object({
+    tx_out_id: zod.z.object({ signature: zod.z.string() }),
+    tx_ref: zod.z.object({
+      transaction_id: zod.z.object({
+        block_number: zod.z.number(),
+        extrinsic_index: zod.z.number()
+      })
+    }).transform(
+      ({ transaction_id }) => `${transaction_id.block_number}-${transaction_id.extrinsic_index}`
+    )
+  }),
+  Assethub: zod.z.object({
+    tx_out_id: zod.z.object({ signature: zod.z.string() }),
+    tx_ref: zod.z.object({
+      transaction_id: zod.z.object({
+        block_number: zod.z.number(),
+        extrinsic_index: zod.z.number()
+      })
+    }).transform(
+      ({ transaction_id }) => `${transaction_id.block_number}-${transaction_id.extrinsic_index}`
+    )
+  }),
+  Bitcoin: zod.z.object({
+    tx_out_id: zod.z.object({ hash: zod.z.string() }),
+    tx_ref: zod.z.object({
+      hash: zod.z.string().transform((value) => value.startsWith("0x") ? value.slice(2) : value)
+    }).transform(({ hash }) => hash)
+  }),
+  Arbitrum: zod.z.object({
+    tx_out_id: zod.z.object({
+      signature: zod.z.object({
+        k_times_g_address: zod.z.array(zod.z.number()),
+        s: zod.z.array(zod.z.number())
+      })
+    }),
+    tx_ref: zod.z.object({
+      hash: hexString
+    }).transform(({ hash }) => hash)
+  })
+};
+var accountFee = zod.z.object({
+  account: chainflipAddress,
+  bps: zod.z.number()
+}).transform(({ account, bps }) => ({ account, commissionBps: bps }));
+var vaultDepositSchema = jsonString.pipe(
+  zod.z.object({
+    amount: u128,
+    destination_address: zod.z.string(),
+    input_asset: assetAndChain,
+    output_asset: assetAndChain,
+    deposit_chain_block_height: zod.z.number().nullable().optional(),
+    affiliate_fees: zod.z.array(accountFee),
+    broker_fee: accountFee.optional(),
+    max_boost_fee: zod.z.number().optional(),
+    dca_params: zod.z.object({
+      chunk_interval: zod.z.number(),
+      number_of_chunks: zod.z.number()
+    }).nullable().optional(),
+    refund_params: zod.z.object({
+      min_price: u128,
+      retry_duration: zod.z.number(),
+      refund_address: zod.z.string()
+    }).nullable().optional(),
+    ccm_deposit_metadata: zod.z.object({
+      channel_metadata: zod.z.object({
+        ccm_additional_data: zod.z.any(),
+        message: zod.z.string(),
+        gas_budget: zod.z.union([numericString, hexString]).transform((n) => number.hexEncodeNumber(BigInt(n)))
+      })
+    }).nullable().optional()
+  }).transform(transformKeysToCamelCase)
+);
+var mempoolTransaction = jsonString.pipe(
+  zod.z.object({
+    confirmations: zod.z.number(),
+    value: u128,
+    tx_hash: zod.z.string(),
+    deposit_chain_block_height: zod.z.number().optional()
+  })
+);
+var RedisClient = class {
+  client;
+  constructor(url) {
+    this.client = new Redis__default.default(url);
+  }
+  async getBroadcast(chain, broadcastId) {
+    if (chain === "Solana") 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 } = chainflip.assetConstants[asset];
+    const parsedAddress = chain === "Polkadot" ? ss58__namespace.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 "Polkadot":
+          return {
+            ...deposit,
+            tx_refs: [`${deposit.deposit_chain_block_height}-${deposit_details.extrinsic_index}`]
+          };
+        default:
+          assert__default.default(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", "Polkadot", "Assethub"];
+    if (unavailableChains.includes(chain)) return null;
+    const redisTxId = chain === "Bitcoin" && string.isHex(`0x${txId}`) ? bytes.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();
+  }
+};
+
+module.exports = RedisClient;

package/dist/index.d.cts

@@ -0,0 +1,387 @@
+import { ChainflipChain, ChainflipAsset, AssetAndChain } from '@chainflip/utils/chainflip';
+import { z } from 'zod';
+
+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;
+    }>, "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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: "Polkadot";
+        extrinsic_index: number;
+    }, {
+        extrinsic_index: number;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    asset: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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: "Polkadot";
+        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 Polkadot: 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 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'>> = z.infer<(typeof broadcastParsers)[C]>;
+type EthereumBroadcast = ChainBroadcast<'Ethereum'>;
+type PolkadotBroadcast = ChainBroadcast<'Polkadot'>;
+type BitcoinBroadcast = ChainBroadcast<'Bitcoin'>;
+type Broadcast = ChainBroadcast<Exclude<ChainflipChain, 'Solana'>>;
+declare class RedisClient {
+    private client;
+    constructor(url: `redis://${string}` | `rediss://${string}`);
+    getBroadcast(chain: 'Ethereum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
+    getBroadcast(chain: 'Polkadot', broadcastId: number | bigint): Promise<PolkadotBroadcast | 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: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "HubDot" | "HubUsdt" | "HubUsdc";
+        outputAsset: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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 };

package/dist/index.d.ts

@@ -0,0 +1,387 @@
+import { ChainflipChain, ChainflipAsset, AssetAndChain } from '@chainflip/utils/chainflip';
+import { z } from 'zod';
+
+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;
+    }>, "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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: "Polkadot";
+        extrinsic_index: number;
+    }, {
+        extrinsic_index: number;
+    }>]>>;
+}, "strip", z.ZodTypeAny, {
+    asset: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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: "Polkadot";
+        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 Polkadot: 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 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'>> = z.infer<(typeof broadcastParsers)[C]>;
+type EthereumBroadcast = ChainBroadcast<'Ethereum'>;
+type PolkadotBroadcast = ChainBroadcast<'Polkadot'>;
+type BitcoinBroadcast = ChainBroadcast<'Bitcoin'>;
+type Broadcast = ChainBroadcast<Exclude<ChainflipChain, 'Solana'>>;
+declare class RedisClient {
+    private client;
+    constructor(url: `redis://${string}` | `rediss://${string}`);
+    getBroadcast(chain: 'Ethereum', broadcastId: number | bigint): Promise<EthereumBroadcast | null>;
+    getBroadcast(chain: 'Polkadot', broadcastId: number | bigint): Promise<PolkadotBroadcast | 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: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "HubDot" | "HubUsdt" | "HubUsdc";
+        outputAsset: "Eth" | "Flip" | "Usdc" | "Usdt" | "ArbUsdc" | "ArbEth" | "Btc" | "Dot" | "Sol" | "SolUsdc" | "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 };

package/dist/index.js

@@ -0,0 +1,201 @@
+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';
+
+// 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),
+  { message: "Invalid asset and 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 polkadotDeposit = z.object({ extrinsic_index: z.number() }).transform((obj) => ({ ...obj, type: "Polkadot" }));
+var depositSchema = jsonString.pipe(
+  z.object({
+    amount: u128,
+    asset: assetAndChain,
+    deposit_chain_block_height: z.number(),
+    deposit_details: z.union([evmDeposit, bitcoinDeposit, polkadotDeposit]).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)
+  }),
+  Polkadot: 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}`
+    )
+  }),
+  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()
+  })
+);
+var RedisClient = class {
+  client;
+  constructor(url) {
+    this.client = new Redis(url);
+  }
+  async getBroadcast(chain, broadcastId) {
+    if (chain === "Solana") 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 === "Polkadot" ? 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 "Polkadot":
+          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", "Polkadot", "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();
+  }
+};
+
+export { RedisClient as default };

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@chainflip/redis",
+  "version": "1.0.0",
+  "type": "module",
+  "repository": "https://github.com/chainflip-io/chainflip-product-toolkit.git",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "dependencies": {
+    "@chainflip/utils": "0.8.2",
+    "bignumber.js": "^9.1.2",
+    "ioredis": "^5.6.0",
+    "zod": "^3.24.2"
+  },
+  "scripts": {
+    "eslint:check": "pnpm eslint --max-warnings 0 './**/*.ts'",
+    "prettier:base": "prettier ./** --ignore-path=../../.prettierignore",
+    "prettier:check": "pnpm prettier:base --check",
+    "prettier:write": "pnpm prettier:base --write",
+    "prepublish": "pnpm build && pnpm test run",
+    "clean": "rm -rf dist",
+    "tsup:build": "tsup ./src/index.ts --format esm,cjs --dts --treeshake",
+    "build": "pnpm clean && pnpm tsup:build",
+    "test:ci": "CI=1 pnpm t run",
+    "test": "vitest"
+  }
+}