@chainflip/utils 0.11.3 → 2.1.0-beta.0

package/dist/chunk-LJJH7U4M.js

@@ -1,302 +0,0 @@
-// src/chainflip.ts
-var chainflipAssets = [
-  // Ethereum
-  "Usdc",
-  "Usdt",
-  "Flip",
-  "Eth",
-  // Polkadot
-  "Dot",
-  // Bitcoin
-  "Btc",
-  // Arbitrum
-  "ArbUsdc",
-  "ArbEth",
-  // Solana
-  "Sol",
-  "SolUsdc",
-  // Assethub
-  "HubDot",
-  "HubUsdt",
-  "HubUsdc"
-];
-var assetSymbols = ["USDC", "USDT", "FLIP", "DOT", "ETH", "BTC", "SOL"];
-var priceAssets = [
-  "Btc",
-  "Eth",
-  "Sol",
-  "Usdc",
-  "Usdt",
-  "Usd",
-  "Fine"
-  // not used
-];
-var rpcAssets = assetSymbols;
-var baseChainflipAssets = chainflipAssets.filter(
-  (asset) => asset !== "Usdc"
-);
-var chainflipEvmChains = ["Ethereum", "Arbitrum"];
-var chainflipChains = [
-  ...chainflipEvmChains,
-  "Bitcoin",
-  "Polkadot",
-  "Solana",
-  "Assethub"
-];
-var chainflipNetworks = ["backspin", "sisyphos", "perseverance", "mainnet"];
-var addressTypes = ["Eth", "Btc", "Dot", "Arb", "Sol", "Hub"];
-function readAssetValue(map, asset) {
-  const chainValues = map[assetConstants[asset].chain];
-  return chainValues[assetConstants[asset].symbol];
-}
-var assetConstants = {
-  Eth: {
-    chain: "Ethereum",
-    symbol: "ETH",
-    rpcAsset: "ETH",
-    decimals: 18
-  },
-  Flip: {
-    chain: "Ethereum",
-    symbol: "FLIP",
-    rpcAsset: "FLIP",
-    decimals: 18
-  },
-  Usdc: {
-    chain: "Ethereum",
-    symbol: "USDC",
-    rpcAsset: "USDC",
-    decimals: 6
-  },
-  Usdt: {
-    chain: "Ethereum",
-    symbol: "USDT",
-    rpcAsset: "USDT",
-    decimals: 6
-  },
-  Dot: {
-    chain: "Polkadot",
-    symbol: "DOT",
-    rpcAsset: "DOT",
-    decimals: 10
-  },
-  Btc: {
-    chain: "Bitcoin",
-    symbol: "BTC",
-    rpcAsset: "BTC",
-    decimals: 8
-  },
-  ArbUsdc: {
-    chain: "Arbitrum",
-    symbol: "USDC",
-    rpcAsset: "USDC",
-    decimals: 6
-  },
-  ArbEth: {
-    chain: "Arbitrum",
-    symbol: "ETH",
-    rpcAsset: "ETH",
-    decimals: 18
-  },
-  Sol: {
-    chain: "Solana",
-    symbol: "SOL",
-    rpcAsset: "SOL",
-    decimals: 9
-  },
-  SolUsdc: {
-    chain: "Solana",
-    symbol: "USDC",
-    rpcAsset: "USDC",
-    decimals: 6
-  },
-  HubDot: {
-    chain: "Assethub",
-    symbol: "DOT",
-    rpcAsset: "DOT",
-    decimals: 10
-  },
-  HubUsdc: {
-    chain: "Assethub",
-    symbol: "USDC",
-    rpcAsset: "USDC",
-    decimals: 6
-  },
-  HubUsdt: {
-    chain: "Assethub",
-    symbol: "USDT",
-    rpcAsset: "USDT",
-    decimals: 6
-  }
-};
-var chainConstants = {
-  Ethereum: {
-    chainflipAssets: ["Eth", "Flip", "Usdc", "Usdt"],
-    assets: ["ETH", "FLIP", "USDC", "USDT"],
-    rpcAssets: ["ETH", "FLIP", "USDC", "USDT"],
-    gasAsset: "Eth",
-    addressType: "Eth",
-    blockTimeSeconds: 12
-  },
-  Polkadot: {
-    chainflipAssets: ["Dot"],
-    assets: ["DOT"],
-    rpcAssets: ["DOT"],
-    gasAsset: "Dot",
-    addressType: "Dot",
-    blockTimeSeconds: 6
-  },
-  Bitcoin: {
-    chainflipAssets: ["Btc"],
-    assets: ["BTC"],
-    rpcAssets: ["BTC"],
-    gasAsset: "Btc",
-    addressType: "Btc",
-    blockTimeSeconds: 10 * 60
-  },
-  Arbitrum: {
-    chainflipAssets: ["ArbUsdc", "ArbEth"],
-    assets: ["USDC", "ETH"],
-    rpcAssets: ["USDC", "ETH"],
-    gasAsset: "ArbEth",
-    addressType: "Arb",
-    blockTimeSeconds: 0.26
-  },
-  Solana: {
-    chainflipAssets: ["Sol", "SolUsdc"],
-    assets: ["SOL", "USDC"],
-    rpcAssets: ["SOL", "USDC"],
-    gasAsset: "Sol",
-    addressType: "Sol",
-    blockTimeSeconds: 0.8
-  },
-  Assethub: {
-    chainflipAssets: ["HubDot", "HubUsdt", "HubUsdc"],
-    assets: ["DOT", "USDT", "USDC"],
-    rpcAssets: ["DOT", "USDT", "USDC"],
-    gasAsset: "HubDot",
-    addressType: "Hub",
-    blockTimeSeconds: 12
-  }
-};
-var internalAssetToRpcAsset = {
-  Eth: { chain: "Ethereum", asset: "ETH" },
-  Flip: { chain: "Ethereum", asset: "FLIP" },
-  Usdc: { chain: "Ethereum", asset: "USDC" },
-  Usdt: { chain: "Ethereum", asset: "USDT" },
-  Dot: { chain: "Polkadot", asset: "DOT" },
-  Btc: { chain: "Bitcoin", asset: "BTC" },
-  ArbUsdc: { chain: "Arbitrum", asset: "USDC" },
-  ArbEth: { chain: "Arbitrum", asset: "ETH" },
-  Sol: { chain: "Solana", asset: "SOL" },
-  SolUsdc: { chain: "Solana", asset: "USDC" },
-  HubDot: { chain: "Assethub", asset: "DOT" },
-  HubUsdt: { chain: "Assethub", asset: "USDT" },
-  HubUsdc: { chain: "Assethub", asset: "USDC" }
-};
-var chainContractId = {
-  Ethereum: 1,
-  Polkadot: 2,
-  Bitcoin: 3,
-  Arbitrum: 4,
-  Solana: 5,
-  Assethub: 6
-};
-var assetContractId = {
-  Eth: 1,
-  Flip: 2,
-  Usdc: 3,
-  Dot: 4,
-  Usdt: 8,
-  Btc: 5,
-  ArbEth: 6,
-  ArbUsdc: 7,
-  Sol: 9,
-  SolUsdc: 10,
-  HubDot: 11,
-  HubUsdt: 12,
-  HubUsdc: 13
-};
-function getInternalAsset(asset, assert = true) {
-  const map = {
-    Ethereum: {
-      USDC: "Usdc",
-      FLIP: "Flip",
-      ETH: "Eth",
-      USDT: "Usdt"
-    },
-    Bitcoin: {
-      BTC: "Btc"
-    },
-    Arbitrum: {
-      USDC: "ArbUsdc",
-      ETH: "ArbEth"
-    },
-    Solana: {
-      SOL: "Sol",
-      USDC: "SolUsdc"
-    },
-    Assethub: {
-      USDC: "HubUsdc",
-      USDT: "HubUsdt",
-      DOT: "HubDot"
-    }
-  };
-  const chain = map[asset.chain];
-  const internalAsset = chain?.[asset.asset];
-  if (internalAsset) return internalAsset;
-  if (assert) throw new Error(`invalid asset and chain combination: ${JSON.stringify(asset)}`);
-  return null;
-}
-function isValidAssetAndChain(assetAndChain) {
-  const asset = getInternalAsset(assetAndChain, false);
-  return asset !== null;
-}
-function getInternalAssets({
-  srcAsset,
-  srcChain,
-  destAsset,
-  destChain
-}, assert = true) {
-  return {
-    srcAsset: getInternalAsset({ asset: srcAsset, chain: srcChain }, assert),
-    destAsset: getInternalAsset({ asset: destAsset, chain: destChain }, assert)
-  };
-}
-var chainflipAssetToPriceAssetMap = {
-  Btc: "Btc",
-  Sol: "Sol",
-  Eth: "Eth",
-  ArbEth: "Eth",
-  Usdc: "Usdc",
-  ArbUsdc: "Usdc",
-  SolUsdc: "Usdc",
-  HubUsdc: "Usdc",
-  Usdt: "Usdt",
-  HubUsdt: "Usdt",
-  Dot: null,
-  Flip: null,
-  HubDot: null
-};
-
-export {
-  chainflipAssets,
-  assetSymbols,
-  priceAssets,
-  rpcAssets,
-  baseChainflipAssets,
-  chainflipEvmChains,
-  chainflipChains,
-  chainflipNetworks,
-  addressTypes,
-  readAssetValue,
-  assetConstants,
-  chainConstants,
-  internalAssetToRpcAsset,
-  chainContractId,
-  assetContractId,
-  getInternalAsset,
-  isValidAssetAndChain,
-  getInternalAssets,
-  chainflipAssetToPriceAssetMap
-};

package/dist/chunk-XGNPN5CY.js

@@ -1,61 +0,0 @@
-import {
-  assert
-} from "./chunk-ZHIKNZLU.js";
-
-// src/bytes.ts
-var bytesToHex = (input) => {
-  const bytes = new Uint8Array(input);
-  return `0x${Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
-};
-var hexToBytes = (input) => {
-  assert(/^0x[\da-f]*$/i.test(input) && input.length % 2 === 0, "Invalid hex string");
-  const hex = input.slice(2);
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = Number.parseInt(hex.slice(i, i + 2), 16);
-  }
-  return bytes;
-};
-var convertBase = (inputBytes, fromBase, toBase) => {
-  const bytes = typeof inputBytes === "string" ? hexToBytes(inputBytes) : new Uint8Array(inputBytes);
-  const result = [];
-  for (const byte of bytes) {
-    let carry = byte;
-    for (let i = 0; i < result.length; i += 1) {
-      carry += result[i] * fromBase;
-      result[i] = carry % toBase;
-      carry = Math.floor(carry / toBase);
-    }
-    while (carry !== 0) {
-      result.push(carry % toBase);
-      carry = Math.floor(carry / toBase);
-    }
-  }
-  let leadingZeros = 0;
-  while (bytes[leadingZeros] === 0) {
-    leadingZeros += 1;
-    result.push(0);
-  }
-  return result.reverse();
-};
-var encodeBytesWithCharset = (bytes, charset) => convertBase(bytes, 256, charset.length).map((charCode) => charset.charAt(charCode)).join("");
-var decodeBytesWithCharset = (input, charset) => {
-  assert(new RegExp(`^[${charset}]*$`).test(input), "Invalid input");
-  const charMap = Object.fromEntries([...charset].map((char, index) => [char, index]));
-  const bytes = input.split("").map((char) => charMap[char]);
-  return new Uint8Array(convertBase(bytes, charset.length, 256));
-};
-function reverseBytes(input) {
-  const bytes = /^(?:0x)?([\da-f]+)$/gi.exec(input)?.[1];
-  assert(bytes && bytes.length % 2 === 0 && bytes.length > 0, "Invalid hex string");
-  const reversed = bytes.match(/.{2}/g).reverse().join("");
-  return input.startsWith("0x") ? `0x${reversed}` : reversed;
-}
-
-export {
-  bytesToHex,
-  hexToBytes,
-  encodeBytesWithCharset,
-  decodeBytesWithCharset,
-  reverseBytes
-};

package/dist/chunk-ZHIKNZLU.js

@@ -1,66 +0,0 @@
-import {
-  isBigInt,
-  isBoolean,
-  isNumber,
-  isObject,
-  isString,
-  isSymbol,
-  isUndefined
-} from "./chunk-HBIFE4XN.js";
-
-// src/assertion.ts
-function assert(condition, message = "assertion failed", Constructor = Error) {
-  if (!condition) {
-    throw new Constructor(message);
-  }
-}
-function assertString(value, message) {
-  if (!isString(value)) {
-    throw new TypeError(message ?? `expected a "string", got "${typeof value}"`);
-  }
-}
-function assertNumber(value, message) {
-  if (!isNumber(value)) {
-    throw new TypeError(message ?? `expected a "number", got "${typeof value}"`);
-  }
-}
-function assertBigInt(value, message) {
-  if (!isBigInt(value)) {
-    throw new TypeError(message ?? `expected a "bigint", got "${typeof value}"`);
-  }
-}
-function assertBoolean(value, message) {
-  if (!isBoolean(value)) {
-    throw new TypeError(message ?? `expected a "boolean", got "${typeof value}"`);
-  }
-}
-function assertSymbol(value, message) {
-  if (!isSymbol(value)) {
-    throw new TypeError(message ?? `expected a "symbol", got "${typeof value}"`);
-  }
-}
-function assertObject(value, message) {
-  if (!isObject(value)) {
-    throw new TypeError(message ?? `expected an "object", got "${typeof value}"`);
-  }
-}
-function assertUndefined(value, message) {
-  if (!isUndefined(value)) {
-    throw new TypeError(message ?? `expected "undefined", got "${typeof value}"`);
-  }
-}
-var unreachable = (x, message = "unreachable") => {
-  throw new Error(message);
-};
-
-export {
-  assert,
-  assertString,
-  assertNumber,
-  assertBigInt,
-  assertBoolean,
-  assertSymbol,
-  assertObject,
-  assertUndefined,
-  unreachable
-};

package/dist/consts.d.cts

@@ -1,33 +0,0 @@
-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[];
-
-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/date.d.cts

@@ -1,26 +0,0 @@
-import { UTCDate } from '@date-fns/utc';
-import { Interval, DateArg } from 'date-fns';
-
-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[];
-
-export { addUtcDays, differenceInTimeAgo, differenceInUtcDays, eachUtcDayOfInterval, formatTimestamp, formatTimestampShort, fromUnixTime, intervalToDurationWords, subUtcDays, toEndOfUtcDay, toEndOfUtcDayString, toISODateString, toStartOfUtcDay, toStartOfUtcDayString };

package/dist/guard.d.cts

@@ -1,23 +0,0 @@
-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;
-
-export { type TypeMap, isBigInt, isBoolean, isFullfilled, isNotNullish, isNullish, isNumber, isObject, isRejected, isString, isSymbol, isTruthy, isUndefined };

package/dist/math.d.cts

@@ -1,4 +0,0 @@
-declare const sum: (arr: number[]) => number;
-declare const average: (arr: number[]) => number;
-
-export { average, sum };

package/dist/number.d.cts

@@ -1,6 +0,0 @@
-import { HexString } from './types.cjs';
-import './chainflip.cjs';
-
-declare const hexEncodeNumber: (num: number | bigint) => HexString;
-
-export { hexEncodeNumber };

package/dist/ss58.d.cts

@@ -1,14 +0,0 @@
-import { Bytelike, HexString } from './types.cjs';
-import './chainflip.cjs';
-
-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;
-
-export { decode, encode, toPublicKey };

package/dist/string.d.cts

@@ -1,16 +0,0 @@
-import { HexString } from './types.cjs';
-import './chainflip.cjs';
-
-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;
-
-export { abbreviate, capitalize, isBytes, isHex, isInteger, split, toLowerCase, toUpperCase, truncateString, uncapitalize };

package/dist/tickMath.d.cts

@@ -1,15 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { ChainflipAsset } from './chainflip.cjs';
-
-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;
-
-export { FULL_TICK_RANGE, MAX_TICK, MIN_TICK, priceX128ToPrice, rateToTick, sqrtPriceX96ToPrice, tickToRate };

package/dist/types.d.cts

@@ -1,41 +0,0 @@
-import { ChainflipAsset } from './chainflip.cjs';
-
-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;
-};
-
-export type { Bytelike, HexString, VaultSwapData };

package/dist/url.d.cts

@@ -1,6 +0,0 @@
-declare const parseUrlWithBasicAuth: (url: string) => {
-    url: string;
-    headers: {};
-};
-
-export { parseUrlWithBasicAuth };