@chainflip/utils 2.1.0-beta.0 → 2.1.0

package/dist/_virtual/{rolldown_runtime.cjs → _rolldown/runtime.cjs}

@@ -1,4 +1,4 @@
-//#region rolldown:runtime
+//#region \0rolldown/runtime.js
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;

package/dist/addresses.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/addresses.ts
 const FLIP_CONTRACT_ADDRESSES = {

package/dist/{addresses.d.ts → addresses.d.cts}

@@ -1,4 +1,4 @@
-import { ChainflipNetwork } from "./chainflip.js";
+import { ChainflipNetwork } from "./chainflip.cjs";
 
 //#region src/addresses.d.ts
 declare const FLIP_CONTRACT_ADDRESSES: Record<ChainflipNetwork, `0x${string}`>;

package/dist/addresses.d.mts

@@ -0,0 +1,7 @@
+import { ChainflipNetwork } from "./chainflip.mjs";
+
+//#region src/addresses.d.ts
+declare const FLIP_CONTRACT_ADDRESSES: Record<ChainflipNetwork, `0x${string}`>;
+declare const STATE_CHAIN_GATEWAY_ADDRESSES: Record<ChainflipNetwork, `0x${string}`>;
+//#endregion
+export { FLIP_CONTRACT_ADDRESSES, STATE_CHAIN_GATEWAY_ADDRESSES };

package/dist/assertion.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_guard = require('./guard.cjs');
 
 //#region src/assertion.ts

package/dist/assertion.d.mts

@@ -0,0 +1,12 @@
+//#region src/assertion.d.ts
+declare function assert(condition: unknown, message?: string, Constructor?: ErrorConstructor): asserts condition;
+declare function assertString(value: unknown, message?: string): asserts value is string;
+declare function assertNumber(value: unknown, message?: string): asserts value is number;
+declare function assertBigInt(value: unknown, message?: string): asserts value is bigint;
+declare function assertBoolean(value: unknown, message?: string): asserts value is boolean;
+declare function assertSymbol(value: unknown, message?: string): asserts value is symbol;
+declare function assertObject(value: unknown, message?: string): asserts value is object;
+declare function assertUndefined(value: unknown, message?: string): asserts value is undefined;
+declare const unreachable: (x: never, message?: string) => never;
+//#endregion
+export { assert, assertBigInt, assertBoolean, assertNumber, assertObject, assertString, assertSymbol, assertUndefined, unreachable };

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

@@ -1,4 +1,4 @@
-import { isBigInt, isBoolean, isNumber, isObject, isString, isSymbol, isUndefined } from "./guard.js";
+import { isBigInt, isBoolean, isNumber, isObject, isString, isSymbol, isUndefined } from "./guard.mjs";
 
 //#region src/assertion.ts
 function assert(condition, message = "assertion failed", Constructor = Error) {

package/dist/async.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/async.ts
 const deferredPromise = () => {

package/dist/async.d.mts

@@ -0,0 +1,36 @@
+//#region src/async.d.ts
+declare const deferredPromise: <T>() => {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (error: Error) => void;
+};
+type DeferredPromise<T> = ReturnType<typeof deferredPromise<T>>;
+declare const sleep: (ms: number, {
+  signal
+}?: {
+  signal?: AbortSignal;
+}) => Promise<void>;
+declare class Queue {
+  private readonly debounce?;
+  private promise;
+  constructor(debounce?: number | undefined);
+  enqueue<T, Args extends unknown[]>(fn: (...args: Args) => Promise<T>, ...args: Args): Promise<T>;
+}
+declare class RateLimiter<T, Args extends unknown[]> {
+  fn: (...args: Args) => Promise<T>;
+  debounce: number;
+  queues: Queue[];
+  index: number;
+  constructor(opts: {
+    fn: (...args: Args) => Promise<T>;
+    debounce: number;
+    maxConcurrency: number;
+  });
+  request(...args: Args): Promise<T>;
+}
+declare const once: (target: EventTarget, event: string, opts?: {
+  signal?: AbortSignal;
+  timeout?: number;
+}) => Promise<void>;
+//#endregion
+export { DeferredPromise, Queue, RateLimiter, deferredPromise, once, sleep };

package/dist/base58.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_bytes = require('./bytes.cjs');
 
 //#region src/base58.ts

package/dist/{base58.d.ts → base58.d.cts}

@@ -1,4 +1,4 @@
-import { Bytelike } from "./types.js";
+import { Bytelike } from "./types.cjs";
 
 //#region src/base58.d.ts
 declare const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

package/dist/base58.d.mts

@@ -0,0 +1,8 @@
+import { Bytelike } from "./types.mjs";
+
+//#region src/base58.d.ts
+declare const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+declare const encode: (bytes: Bytelike) => string;
+declare const decode: (input: string) => Uint8Array;
+//#endregion
+export { CHARSET, decode, encode };

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

@@ -1,4 +1,4 @@
-import { decodeBytesWithCharset, encodeBytesWithCharset } from "./bytes.js";
+import { decodeBytesWithCharset, encodeBytesWithCharset } from "./bytes.mjs";
 
 //#region src/base58.ts
 const CHARSET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

package/dist/bytes.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_assertion = require('./assertion.cjs');
 
 //#region src/bytes.ts

package/dist/{bytes.d.ts → bytes.d.cts}

@@ -1,4 +1,4 @@
-import { Bytelike, HexString } from "./types.js";
+import { Bytelike, HexString } from "./types.cjs";
 
 //#region src/bytes.d.ts
 declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;

package/dist/bytes.d.mts

@@ -0,0 +1,11 @@
+import { Bytelike, HexString } from "./types.mjs";
+
+//#region src/bytes.d.ts
+declare const bytesToHex: (input: Uint8Array | number[]) => `0x${string}`;
+declare const hexToBytes: (input: HexString) => Uint8Array;
+declare const encodeBytesWithCharset: (bytes: Bytelike, charset: string) => string;
+declare const decodeBytesWithCharset: (input: string, charset: string) => Uint8Array;
+declare function reverseBytes(input: HexString): HexString;
+declare function reverseBytes(input: string): string;
+//#endregion
+export { bytesToHex, decodeBytesWithCharset, encodeBytesWithCharset, hexToBytes, reverseBytes };

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

@@ -1,4 +1,4 @@
-import { assert } from "./assertion.js";
+import { assert } from "./assertion.mjs";
 
 //#region src/bytes.ts
 const bytesToHex = (input) => {

package/dist/chainflip.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/chainflip.ts
 const chainflipAssets = [

package/dist/chainflip.d.mts

@@ -0,0 +1,239 @@
+//#region src/chainflip.d.ts
+declare const chainflipAssets: readonly ["Usdc", "Usdt", "Wbtc", "Flip", "Eth", "Dot", "Btc", "ArbUsdc", "ArbUsdt", "ArbEth", "Sol", "SolUsdc", "SolUsdt", "HubDot", "HubUsdt", "HubUsdc"];
+type ChainflipAsset = (typeof chainflipAssets)[number];
+declare const assetSymbols: readonly ["USDC", "USDT", "WBTC", "FLIP", "DOT", "ETH", "BTC", "SOL"];
+declare const priceAssets: readonly ["Btc", "Eth", "Sol", "Usdc", "Usdt", "Usd", "Fine"];
+type PriceAsset = (typeof priceAssets)[number];
+/** @deprecated use `assetSymbols` instead */
+declare const rpcAssets: readonly ["USDC", "USDT", "WBTC", "FLIP", "DOT", "ETH", "BTC", "SOL"];
+type AssetSymbol = (typeof assetSymbols)[number];
+/** @deprecated use `AssetSymbol` instead */
+type RpcAsset = AssetSymbol;
+type BaseChainflipAsset = Exclude<ChainflipAsset, 'Usdc'>;
+declare const baseChainflipAssets: BaseChainflipAsset[];
+declare const chainflipEvmChains: readonly ["Ethereum", "Arbitrum"];
+type ChainflipEvmChain = (typeof chainflipEvmChains)[number];
+declare const chainflipChains: readonly ["Ethereum", "Arbitrum", "Bitcoin", "Polkadot", "Solana", "Assethub"];
+type ChainflipChain = (typeof chainflipChains)[number];
+declare const chainflipNetworks: readonly ["backspin", "sisyphos", "perseverance", "mainnet"];
+type ChainflipNetwork = (typeof chainflipNetworks)[number];
+declare const addressTypes: readonly ["Eth", "Btc", "Dot", "Arb", "Sol", "Hub"];
+type AddressType = (typeof addressTypes)[number];
+type AssetOfChain<C extends Exclude<ChainflipChain, 'Polkadot'>> = (typeof chainConstants)[C]['assets'][number];
+type ChainAssetMap<T> = { [C in Exclude<ChainflipChain, 'Polkadot'>]: { [A in AssetOfChain<C>]: T } };
+type BaseChainAssetMap<T> = { [C in Exclude<ChainflipChain, 'Polkadot'>]: { [A in Exclude<BaseChainflipAsset, 'Dot'> as Extract<(typeof assetConstants)[A], {
+  chain: C;
+}>['symbol']]: T } };
+type AssetAndChain = { [C in Exclude<ChainflipChain, 'Polkadot'>]: { [A in keyof ChainAssetMap<unknown>[C]]: {
+  chain: C;
+  asset: A;
+} }[keyof ChainAssetMap<unknown>[C]] }[Exclude<ChainflipChain, 'Polkadot'>];
+type BaseAssetAndChain = Exclude<AssetAndChain, {
+  chain: 'Ethereum';
+  asset: 'USDC';
+}>;
+type ChainMap<T> = { [C in Exclude<ChainflipChain, 'Polkadot'>]: T };
+type InternalAssetMap<T> = { [A in Exclude<ChainflipAsset, 'Dot'>]: T };
+type UncheckedAssetAndChain = {
+  chain: ChainflipChain;
+  asset: AssetSymbol;
+};
+declare function readAssetValue<T>(map: ChainAssetMap<T>, asset: ChainflipAsset | BaseChainflipAsset): T;
+declare function readAssetValue<T>(map: BaseChainAssetMap<T>, asset: BaseChainflipAsset): T;
+declare function readAssetValue<T>(map: ChainAssetMap<T> | BaseChainAssetMap<T>, asset: BaseChainflipAsset): T;
+declare const assetConstants: {
+  readonly Eth: {
+    readonly chain: "Ethereum";
+    readonly symbol: "ETH";
+    readonly rpcAsset: "ETH";
+    readonly decimals: 18;
+  };
+  readonly Flip: {
+    readonly chain: "Ethereum";
+    readonly symbol: "FLIP";
+    readonly rpcAsset: "FLIP";
+    readonly decimals: 18;
+  };
+  readonly Usdc: {
+    readonly chain: "Ethereum";
+    readonly symbol: "USDC";
+    readonly rpcAsset: "USDC";
+    readonly decimals: 6;
+  };
+  readonly Usdt: {
+    readonly chain: "Ethereum";
+    readonly symbol: "USDT";
+    readonly rpcAsset: "USDT";
+    readonly decimals: 6;
+  };
+  readonly Wbtc: {
+    readonly chain: "Ethereum";
+    readonly symbol: "WBTC";
+    readonly rpcAsset: "WBTC";
+    readonly decimals: 8;
+  };
+  readonly Dot: {
+    readonly chain: "Polkadot";
+    readonly symbol: "DOT";
+    readonly rpcAsset: "DOT";
+    readonly decimals: 10;
+  };
+  readonly Btc: {
+    readonly chain: "Bitcoin";
+    readonly symbol: "BTC";
+    readonly rpcAsset: "BTC";
+    readonly decimals: 8;
+  };
+  readonly ArbUsdc: {
+    readonly chain: "Arbitrum";
+    readonly symbol: "USDC";
+    readonly rpcAsset: "USDC";
+    readonly decimals: 6;
+  };
+  readonly ArbUsdt: {
+    readonly chain: "Arbitrum";
+    readonly symbol: "USDT";
+    readonly rpcAsset: "USDT";
+    readonly decimals: 6;
+  };
+  readonly ArbEth: {
+    readonly chain: "Arbitrum";
+    readonly symbol: "ETH";
+    readonly rpcAsset: "ETH";
+    readonly decimals: 18;
+  };
+  readonly Sol: {
+    readonly chain: "Solana";
+    readonly symbol: "SOL";
+    readonly rpcAsset: "SOL";
+    readonly decimals: 9;
+  };
+  readonly SolUsdc: {
+    readonly chain: "Solana";
+    readonly symbol: "USDC";
+    readonly rpcAsset: "USDC";
+    readonly decimals: 6;
+  };
+  readonly SolUsdt: {
+    readonly chain: "Solana";
+    readonly symbol: "USDT";
+    readonly rpcAsset: "USDT";
+    readonly decimals: 6;
+  };
+  readonly HubDot: {
+    readonly chain: "Assethub";
+    readonly symbol: "DOT";
+    readonly rpcAsset: "DOT";
+    readonly decimals: 10;
+  };
+  readonly HubUsdc: {
+    readonly chain: "Assethub";
+    readonly symbol: "USDC";
+    readonly rpcAsset: "USDC";
+    readonly decimals: 6;
+  };
+  readonly HubUsdt: {
+    readonly chain: "Assethub";
+    readonly symbol: "USDT";
+    readonly rpcAsset: "USDT";
+    readonly decimals: 6;
+  };
+};
+declare const chainConstants: {
+  readonly Ethereum: {
+    readonly chainflipAssets: ["Eth", "Flip", "Usdc", "Usdt", "Wbtc"];
+    readonly assets: ["ETH", "FLIP", "USDC", "USDT", "WBTC"];
+    readonly rpcAssets: ["ETH", "FLIP", "USDC", "USDT", "WBTC"];
+    readonly gasAsset: "Eth";
+    readonly addressType: "Eth";
+    readonly blockTimeSeconds: 12;
+  };
+  readonly Polkadot: {
+    readonly chainflipAssets: ["Dot"];
+    readonly assets: ["DOT"];
+    readonly rpcAssets: ["DOT"];
+    readonly gasAsset: "Dot";
+    readonly addressType: "Dot";
+    readonly blockTimeSeconds: 6;
+  };
+  readonly Bitcoin: {
+    readonly chainflipAssets: ["Btc"];
+    readonly assets: ["BTC"];
+    readonly rpcAssets: ["BTC"];
+    readonly gasAsset: "Btc";
+    readonly addressType: "Btc";
+    readonly blockTimeSeconds: number;
+  };
+  readonly Arbitrum: {
+    readonly chainflipAssets: ["ArbUsdc", "ArbUsdt", "ArbEth"];
+    readonly assets: ["USDC", "USDT", "ETH"];
+    readonly rpcAssets: ["USDC", "USDT", "ETH"];
+    readonly gasAsset: "ArbEth";
+    readonly addressType: "Arb";
+    readonly blockTimeSeconds: 0.26;
+  };
+  readonly Solana: {
+    readonly chainflipAssets: ["Sol", "SolUsdc", "SolUsdt"];
+    readonly assets: ["SOL", "USDC", "USDT"];
+    readonly rpcAssets: ["SOL", "USDC", "USDT"];
+    readonly gasAsset: "Sol";
+    readonly addressType: "Sol";
+    readonly blockTimeSeconds: 0.8;
+  };
+  readonly Assethub: {
+    readonly chainflipAssets: ["HubDot", "HubUsdt", "HubUsdc"];
+    readonly assets: ["DOT", "USDT", "USDC"];
+    readonly rpcAssets: ["DOT", "USDT", "USDC"];
+    readonly gasAsset: "HubDot";
+    readonly addressType: "Hub";
+    readonly blockTimeSeconds: 12;
+  };
+};
+declare const internalAssetToRpcAsset: InternalAssetMap<AssetAndChain> & {
+  Dot: {
+    chain: 'Polkadot';
+    asset: 'DOT';
+  };
+};
+declare const chainContractId: ChainMap<number> & {
+  Polkadot: 2;
+};
+declare const assetContractId: InternalAssetMap<number> & {
+  Dot: 4;
+};
+declare function getInternalAsset(asset: BaseAssetAndChain): BaseChainflipAsset;
+declare function getInternalAsset(asset: AssetAndChain): ChainflipAsset;
+declare function getInternalAsset(asset: UncheckedAssetAndChain): ChainflipAsset;
+declare function getInternalAsset(asset: UncheckedAssetAndChain, assert: true): ChainflipAsset;
+declare function getInternalAsset(asset: UncheckedAssetAndChain, assert: boolean): ChainflipAsset | null;
+declare function isValidAssetAndChain(assetAndChain: UncheckedAssetAndChain): assetAndChain is AssetAndChain;
+declare function getInternalAssets(data: {
+  srcAsset: AssetSymbol;
+  srcChain: ChainflipChain;
+  destAsset: AssetSymbol;
+  destChain: ChainflipChain;
+}): {
+  srcAsset: ChainflipAsset;
+  destAsset: ChainflipAsset;
+};
+declare function getInternalAssets(data: {
+  srcAsset: AssetSymbol;
+  srcChain: ChainflipChain;
+  destAsset: AssetSymbol;
+  destChain: ChainflipChain;
+}, assert: true): {
+  srcAsset: ChainflipAsset;
+  destAsset: ChainflipAsset;
+};
+declare function getInternalAssets(data: {
+  srcAsset: AssetSymbol;
+  srcChain: ChainflipChain;
+  destAsset: AssetSymbol;
+  destChain: ChainflipChain;
+}, assert: boolean): {
+  srcAsset: ChainflipAsset | null;
+  destAsset: ChainflipAsset | null;
+};
+declare const chainflipAssetToPriceAssetMap: Record<ChainflipAsset, Exclude<PriceAsset, 'Usd'> | null>;
+//#endregion
+export { AddressType, AssetAndChain, AssetOfChain, AssetSymbol, BaseAssetAndChain, BaseChainAssetMap, BaseChainflipAsset, ChainAssetMap, ChainMap, ChainflipAsset, ChainflipChain, ChainflipEvmChain, ChainflipNetwork, InternalAssetMap, PriceAsset, RpcAsset, UncheckedAssetAndChain, addressTypes, assetConstants, assetContractId, assetSymbols, baseChainflipAssets, chainConstants, chainContractId, chainflipAssetToPriceAssetMap, chainflipAssets, chainflipChains, chainflipEvmChains, chainflipNetworks, getInternalAsset, getInternalAssets, internalAssetToRpcAsset, isValidAssetAndChain, priceAssets, readAssetValue, rpcAssets };

package/dist/consts.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/consts.ts
 const HEARTBEAT_BLOCK_INTERVAL = 150;
@@ -202,6 +203,14 @@ const brokerAliasMap = {
 	cFJt567jd8vooomo6z86sS9qenBodSYyPb6CKgqGESYJS4cFG: {
 		name: "Ellipal Wallet",
 		twitter: "@ellipalwallet"
+	},
+	cFPZ7XoAWHFBJy2t2t5rupQ3fvMKRyCpxDHjnmtD42XAEjxcW: {
+		name: "SafePal",
+		twitter: "@SafePal"
+	},
+	cFNqDaZ9apGKt9uXaGQGucWuizVeTms2cXq8hnYM8g7y99Cpy: {
+		name: "Trocador",
+		twitter: "@TrocadorApp"
 	}
 };
 const lpAliasMap = {

package/dist/consts.d.mts

@@ -0,0 +1,34 @@
+//#region src/consts.d.ts
+declare const HEARTBEAT_BLOCK_INTERVAL = 150;
+declare const CHAINFLIP_SS58_PREFIX = 2112;
+declare const POLKADOT_SS58_PREFIX = 0;
+declare const CHAINFLIP_BLOCK_TIME_SECONDS = 6;
+declare const CHAINFLIP_BLOCKS_PER_YEAR = 5256000;
+declare const chainflipLinks: {
+  website: string;
+  discord: string;
+  twitter: string;
+  telegram: string;
+  blog: string;
+  docs: string;
+};
+declare const chainflipCommunityLinks: {
+  discord: string;
+  twitter: string;
+  telegram: string;
+};
+type AccountAliasMap = {
+  [account: string]: {
+    name: string;
+    twitter: string | null;
+  };
+};
+declare const smartContractAliasMap: {
+  '0xce16f69375520ab01377ce7b88f5ba8c48f8d666': string;
+  '0xd99ac0681b904991169a4f398b9043781adbe0c3': string;
+};
+declare const brokerAliasMap: AccountAliasMap;
+declare const lpAliasMap: AccountAliasMap;
+declare const GENESIS_LP_ACCOUNT_IDS: string[];
+//#endregion
+export { CHAINFLIP_BLOCKS_PER_YEAR, CHAINFLIP_BLOCK_TIME_SECONDS, CHAINFLIP_SS58_PREFIX, GENESIS_LP_ACCOUNT_IDS, HEARTBEAT_BLOCK_INTERVAL, POLKADOT_SS58_PREFIX, brokerAliasMap, chainflipCommunityLinks, chainflipLinks, lpAliasMap, smartContractAliasMap };

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

@@ -201,6 +201,14 @@ const brokerAliasMap = {
 	cFJt567jd8vooomo6z86sS9qenBodSYyPb6CKgqGESYJS4cFG: {
 		name: "Ellipal Wallet",
 		twitter: "@ellipalwallet"
+	},
+	cFPZ7XoAWHFBJy2t2t5rupQ3fvMKRyCpxDHjnmtD42XAEjxcW: {
+		name: "SafePal",
+		twitter: "@SafePal"
+	},
+	cFNqDaZ9apGKt9uXaGQGucWuizVeTms2cXq8hnYM8g7y99Cpy: {
+		name: "Trocador",
+		twitter: "@TrocadorApp"
 	}
 };
 const lpAliasMap = {

package/dist/date.cjs

@@ -1,4 +1,5 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_guard = require('./guard.cjs');
 let _date_fns_utc = require("@date-fns/utc");
 let date_fns = require("date-fns");

package/dist/date.d.mts

@@ -0,0 +1,27 @@
+import { UTCDate } from "@date-fns/utc";
+import { DateArg, Interval } from "date-fns";
+
+//#region src/date.d.ts
+declare const toISODateString: (date: Date) => string;
+declare const fromUnixTime: (time: string | number) => Date;
+declare const formatTimestamp: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const formatTimestampShort: (timestamp: string, locale?: string | undefined, timeZone?: undefined | "UTC") => string;
+declare const differenceInTimeAgo: (time: string, ago?: boolean, endTime?: string) => string;
+declare const intervalToDurationWords: (interval: Interval) => string;
+type FNSDate = DateArg<Date>;
+declare const subUtcDays: (date: FNSDate, days: number) => UTCDate;
+declare const addUtcDays: (date: FNSDate, days: number) => UTCDate;
+declare const toStartOfUtcDay: (date: FNSDate) => UTCDate;
+declare const toStartOfUtcDayString: (date: FNSDate) => string;
+declare const toEndOfUtcDay: (date: FNSDate) => UTCDate;
+declare const toEndOfUtcDayString: (date: FNSDate) => string;
+declare const differenceInUtcDays: (interval: {
+  start: FNSDate;
+  end: FNSDate;
+}) => number;
+declare const eachUtcDayOfInterval: (interval: {
+  start: FNSDate;
+  end: FNSDate;
+}) => UTCDate[];
+//#endregion
+export { addUtcDays, differenceInTimeAgo, differenceInUtcDays, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, subUtcDays, toEndOfUtcDay, toEndOfUtcDayString, toISODateString, toStartOfUtcDay, toStartOfUtcDayString };

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

@@ -1,4 +1,4 @@
-import { isNullish } from "./guard.js";
+import { isNullish } from "./guard.mjs";
 import { utc } from "@date-fns/utc";
 import { addDays, differenceInDays, differenceInHours, differenceInMinutes, differenceInSeconds, eachDayOfInterval, endOfDay, intervalToDuration, startOfDay, subDays } from "date-fns";
 

package/dist/guard.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/guard.ts
 const createIsGuard = (type) => (value) => typeof value === type;

package/dist/guard.d.mts

@@ -0,0 +1,24 @@
+//#region src/guard.d.ts
+type TypeMap = {
+  string: string;
+  number: number;
+  bigint: bigint;
+  boolean: boolean;
+  symbol: symbol;
+  object: object;
+  undefined: undefined;
+};
+declare const isString: (value: unknown) => value is TypeMap["string"];
+declare const isNumber: (value: unknown) => value is TypeMap["number"];
+declare const isBigInt: (value: unknown) => value is TypeMap["bigint"];
+declare const isBoolean: (value: unknown) => value is TypeMap["boolean"];
+declare const isSymbol: (value: unknown) => value is TypeMap["symbol"];
+declare const isObject: (value: unknown) => value is TypeMap["object"];
+declare const isUndefined: (value: unknown) => value is TypeMap["undefined"];
+declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;
+declare const isNullish: (value: unknown) => value is null | undefined;
+declare const isTruthy: <T>(value: T | null | undefined) => value is T;
+declare const isFullfilled: <T>(value: PromiseSettledResult<T>) => value is PromiseFulfilledResult<T>;
+declare const isRejected: <T>(value: PromiseSettledResult<T>) => value is PromiseRejectedResult;
+//#endregion
+export { TypeMap, isBigInt, isBoolean, isFullfilled, isNotNullish, isNullish, isNumber, isObject, isRejected, isString, isSymbol, isTruthy, isUndefined };

package/dist/math.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/math.ts
 const sum = (arr) => arr.reduce((a, b) => a + b, 0);

package/dist/math.d.mts

@@ -0,0 +1,5 @@
+//#region src/math.d.ts
+declare const sum: (arr: number[]) => number;
+declare const average: (arr: number[]) => number;
+//#endregion
+export { average, sum };

package/dist/number.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/number.ts
 const hexEncodeNumber = (num) => `0x${num.toString(16)}`;

package/dist/{number.d.ts → number.d.cts}

@@ -1,4 +1,4 @@
-import { HexString } from "./types.js";
+import { HexString } from "./types.cjs";
 
 //#region src/number.d.ts
 declare const hexEncodeNumber: (num: number | bigint) => HexString;

package/dist/number.d.mts

@@ -0,0 +1,6 @@
+import { HexString } from "./types.mjs";
+
+//#region src/number.d.ts
+declare const hexEncodeNumber: (num: number | bigint) => HexString;
+//#endregion
+export { hexEncodeNumber };

package/dist/ss58.cjs

@@ -1,4 +1,5 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_assertion = require('./assertion.cjs');
 const require_bytes = require('./bytes.cjs');
 const require_base58 = require('./base58.cjs');

package/dist/{ss58.d.ts → ss58.d.cts}

@@ -1,4 +1,4 @@
-import { Bytelike, HexString } from "./types.js";
+import { Bytelike, HexString } from "./types.cjs";
 
 //#region src/ss58.d.ts
 declare const decode: (input: string) => {

package/dist/ss58.d.mts

@@ -0,0 +1,17 @@
+import { Bytelike, HexString } from "./types.mjs";
+
+//#region src/ss58.d.ts
+declare const decode: (input: string) => {
+  data: Uint8Array;
+  ss58Format: number;
+};
+declare const encode: ({
+  data: input,
+  ss58Format
+}: {
+  data: Bytelike;
+  ss58Format: number;
+}) => string;
+declare const toPublicKey: (address: string) => HexString;
+//#endregion
+export { decode, encode, toPublicKey };

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

@@ -1,6 +1,6 @@
-import { assert } from "./assertion.js";
-import { bytesToHex, hexToBytes } from "./bytes.js";
-import { decode as decode$1, encode as encode$1 } from "./base58.js";
+import { assert } from "./assertion.mjs";
+import { bytesToHex, hexToBytes } from "./bytes.mjs";
+import { decode as decode$1, encode as encode$1 } from "./base58.mjs";
 import { blake2b } from "@noble/hashes/blake2.js";
 
 //#region src/ss58.ts

package/dist/string.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/string.ts
 const toUpperCase = (str) => str.toUpperCase();

package/dist/{string.d.ts → string.d.cts}

@@ -1,4 +1,4 @@
-import { HexString } from "./types.js";
+import { HexString } from "./types.cjs";
 
 //#region src/string.d.ts
 declare const toUpperCase: <const T extends string>(str: T) => Uppercase<T>;

package/dist/string.d.mts

@@ -0,0 +1,16 @@
+import { HexString } from "./types.mjs";
+
+//#region src/string.d.ts
+declare const toUpperCase: <const T extends string>(str: T) => Uppercase<T>;
+declare const toLowerCase: <const T extends string>(str: T) => Lowercase<T>;
+declare const isInteger: (string: string) => boolean;
+type Split<T extends string, D extends string> = T extends `${infer L}${D}${infer R}` ? [L, ...Split<R, D>] : [T];
+declare const split: <const T extends string, D extends string>(str: T, delimiter: D) => Split<T, D>;
+declare const capitalize: <const T extends string>(str: T) => Capitalize<T>;
+declare const uncapitalize: <const T extends string>(str: T) => Uncapitalize<T>;
+declare const isHex: (str: string) => str is HexString;
+declare const isBytes: (str: string) => boolean;
+declare const abbreviate: (text: string | undefined | null, showLength?: number, space?: boolean) => string;
+declare const truncateString: (string: string, numCharacters?: number, ellipsis?: boolean) => string;
+//#endregion
+export { abbreviate, capitalize, isBytes, isHex, isInteger, split, toLowerCase, toUpperCase, truncateString, uncapitalize };

package/dist/tickMath.cjs

@@ -1,7 +1,8 @@
-const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
 const require_chainflip = require('./chainflip.cjs');
 let bignumber_js = require("bignumber.js");
-bignumber_js = require_rolldown_runtime.__toESM(bignumber_js);
+bignumber_js = require_runtime.__toESM(bignumber_js);
 
 //#region src/tickMath.ts
 const MIN_TICK = -887272;

package/dist/{tickMath.d.ts → tickMath.d.cts}

@@ -1,4 +1,4 @@
-import { ChainflipAsset } from "./chainflip.js";
+import { ChainflipAsset } from "./chainflip.cjs";
 import BigNumber from "bignumber.js";
 
 //#region src/tickMath.d.ts

package/dist/tickMath.d.mts

@@ -0,0 +1,16 @@
+import { ChainflipAsset } from "./chainflip.mjs";
+import BigNumber from "bignumber.js";
+
+//#region src/tickMath.d.ts
+declare const MIN_TICK = -887272;
+declare const MAX_TICK: number;
+declare const FULL_TICK_RANGE: {
+  start: number;
+  end: number;
+};
+declare const tickToRate: (tick: number, baseAsset: ChainflipAsset) => number;
+declare const rateToTick: (rate: BigNumber.Value, baseAsset: ChainflipAsset) => number;
+declare const sqrtPriceX96ToPrice: (amount: string) => BigNumber;
+declare const priceX128ToPrice: (amount: string) => BigNumber;
+//#endregion
+export { FULL_TICK_RANGE, MAX_TICK, MIN_TICK, priceX128ToPrice, rateToTick, sqrtPriceX96ToPrice, tickToRate };

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

@@ -1,4 +1,4 @@
-import { assetConstants } from "./chainflip.js";
+import { assetConstants } from "./chainflip.mjs";
 import BigNumber from "bignumber.js";
 
 //#region src/tickMath.ts

package/dist/{types.d.ts → types.d.cts}

@@ -1,4 +1,4 @@
-import { ChainflipAsset } from "./chainflip.js";
+import { ChainflipAsset } from "./chainflip.cjs";
 
 //#region src/types.d.ts
 type HexString = `0x${string}`;

package/dist/types.d.mts

@@ -0,0 +1,42 @@
+import { ChainflipAsset } from "./chainflip.mjs";
+
+//#region src/types.d.ts
+type HexString = `0x${string}`;
+type Bytelike = Uint8Array | number[] | HexString;
+type CcmMetadata<Data = never> = {
+  channelMetadata: {
+    message: HexString;
+    gasBudget: HexString;
+  };
+  ccmAdditionalData: Data;
+};
+type VaultSwapData<Broker, CcmData = never> = {
+  amount: bigint;
+  destinationAddress: string;
+  inputAsset: ChainflipAsset;
+  outputAsset: ChainflipAsset;
+  depositChainBlockHeight: number | null;
+  brokerFee: {
+    account: Broker;
+    commissionBps: number;
+  };
+  affiliateFees: {
+    accountIndex: number;
+    commissionBps: number;
+  }[];
+  maxBoostFee: number;
+  dcaParams: {
+    chunkInterval: number;
+    numberOfChunks: number;
+  } | null;
+  refundParams: {
+    refundAddress: string;
+    minPrice: bigint;
+    retryDuration: number;
+    maxOraclePriceSlippage: number | null;
+    refundCcmMetadata: CcmMetadata<CcmData> | null;
+  };
+  ccmDepositMetadata: CcmMetadata<CcmData> | null;
+};
+//#endregion
+export { Bytelike, HexString, VaultSwapData };

package/dist/url.cjs

@@ -1,3 +1,4 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 //#region src/url.ts
 const parseUrlWithBasicAuth = (url) => {

package/dist/url.d.mts

@@ -0,0 +1,7 @@
+//#region src/url.d.ts
+declare const parseUrlWithBasicAuth: (url: string) => {
+  url: string;
+  headers: {};
+};
+//#endregion
+export { parseUrlWithBasicAuth };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chainflip/utils",
-  "version": "2.1.0-beta.0",
+  "version": "2.1.0",
   "type": "module",
   "files": [
     "dist",
@@ -9,22 +9,15 @@
   "exports": {
     "./*": {
       "require": {
-        "types": "./dist/*.d.ts",
+        "types": "./dist/*.d.cts",
         "default": "./dist/*.cjs"
       },
       "import": {
-        "types": "./dist/*.d.ts",
-        "default": "./dist/*.js"
+        "types": "./dist/*.d.mts",
+        "default": "./dist/*.mjs"
       }
     }
   },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "dist/*.d.ts"
-      ]
-    }
-  },
   "devDependencies": {
     "@vitest/ui": "4.0.18"
   },