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

package/dist/parsers.js

@@ -0,0 +1,114 @@
+import { transformKeysToCamelCase } from "./utils.js";
+import { reverseBytes } from "@chainflip/utils/bytes";
+import { getInternalAsset, isValidAssetAndChain } from "@chainflip/utils/chainflip";
+import * as ss58 from "@chainflip/utils/ss58";
+import { CHAINFLIP_SS58_PREFIX } from "@chainflip/utils/consts";
+import { hexEncodeNumber } from "@chainflip/utils/number";
+import { z } from "zod";
+
+//#region src/parsers.ts
+const assetAndChain = z.object({
+	asset: z.string(),
+	chain: z.string()
+}).refine((value) => isValidAssetAndChain(value), (value) => ({ message: `Invalid asset and chain : ${value.asset} on ${value.chain}` })).transform((value) => getInternalAsset(value));
+const numericString = z.string().regex(/^[0-9]+$/);
+const hexString = z.string().refine((v) => /^0x[0-9a-f]*$/i.test(v));
+const u128 = z.union([
+	z.number(),
+	numericString,
+	hexString
+]).transform((arg) => BigInt(arg));
+const chainflipAddress = z.string().refine((address) => ss58.decode(address).ss58Format === CHAINFLIP_SS58_PREFIX, (address) => ({ message: `${address} is not a valid Chainflip address` }));
+const jsonString = z.string().transform((value) => JSON.parse(value));
+const bitcoinDeposit = z.object({
+	tx_id: hexString.transform((value) => reverseBytes(value).slice(2)),
+	vout: z.number().int()
+}).transform((obj) => ({
+	...obj,
+	type: "Bitcoin"
+}));
+const evmDeposit = z.object({ tx_hashes: z.array(hexString) }).transform((obj) => ({
+	...obj,
+	type: "EVM"
+}));
+const assethubDeposit = z.object({ extrinsic_index: z.number() }).transform((obj) => ({
+	...obj,
+	type: "Assethub"
+}));
+const depositSchema = jsonString.pipe(z.object({
+	amount: u128,
+	asset: assetAndChain,
+	deposit_chain_block_height: z.number(),
+	deposit_details: z.union([
+		evmDeposit,
+		bitcoinDeposit,
+		assethubDeposit
+	]).nullable()
+}));
+const 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)
+	})
+};
+const accountFee = z.object({
+	account: chainflipAddress,
+	bps: z.number()
+}).transform(({ account, bps }) => ({
+	account,
+	commissionBps: bps
+}));
+const 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));
+const mempoolTransaction = jsonString.pipe(z.object({
+	confirmations: z.number(),
+	value: u128,
+	tx_hash: z.string(),
+	deposit_chain_block_height: z.number().optional()
+}));
+
+//#endregion
+export { broadcastParsers, depositSchema, mempoolTransaction, vaultDepositSchema };

package/dist/utils.cjs

@@ -0,0 +1,12 @@
+
+//#region src/utils.ts
+const snakeToCamelCase = (str) => str.replace(/_(.)/g, (match, group) => group.toUpperCase());
+const 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)]));
+};
+
+//#endregion
+exports.snakeToCamelCase = snakeToCamelCase;
+exports.transformKeysToCamelCase = transformKeysToCamelCase;

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+//#region src/utils.d.ts
+type SnakeToCamelCase<T extends string> = T extends `${infer P}_${infer S}` ? `${P}${Capitalize<SnakeToCamelCase<S>>}` : T;
+declare const snakeToCamelCase: <const T extends string>(str: T) => SnakeToCamelCase<T>;
+type CamelCasedKeys<T> = T extends Record<string, unknown> ? { [K in keyof T as K extends string ? SnakeToCamelCase<K> : K]: CamelCasedKeys<T[K]> } : T extends (infer U)[] ? CamelCasedKeys<U>[] : T;
+declare const transformKeysToCamelCase: <T>(obj: T) => CamelCasedKeys<T>;
+//#endregion
+export { snakeToCamelCase, transformKeysToCamelCase };

package/dist/utils.js

@@ -0,0 +1,10 @@
+//#region src/utils.ts
+const snakeToCamelCase = (str) => str.replace(/_(.)/g, (match, group) => group.toUpperCase());
+const 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)]));
+};
+
+//#endregion
+export { snakeToCamelCase, transformKeysToCamelCase };

package/package.json

@@ -1,19 +1,7 @@
 {
   "name": "@chainflip/redis",
-  "version": "1.0.2-wbtc-dev.2",
+  "version": "2.1.0-beta.0",
   "type": "module",
-  "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"
-  },
   "repository": "https://github.com/chainflip-io/chainflip-product-toolkit.git",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
@@ -26,7 +14,7 @@
   "exports": {
     ".": {
       "require": {
-        "types": "./dist/index.d.cts",
+        "types": "./dist/index.d.ts",
         "default": "./dist/index.cjs"
       },
       "import": {
@@ -38,7 +26,17 @@
   "dependencies": {
     "@chainflip/utils": "0.11.2-wbtc-dev.2",
     "bignumber.js": "^9.3.1",
-    "ioredis": "^5.8.2",
+    "ioredis": "^5.9.2",
     "zod": "^3.25.75"
+  },
+  "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",
+    "build": "tsdown",
+    "test:ci": "CI=1 pnpm t run",
+    "test": "vitest"
   }
-}
+}

package/dist/index.d.cts

@@ -1,336 +0,0 @@
-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;
-    }>, "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'>>;
-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">;
-}
-
-export { RedisClient as default };