@chainflip/utils 0.4.0 → 0.4.1

package/dist/assertion.js

@@ -8,8 +8,8 @@ import {
   assertSymbol,
   assertUndefined,
   unreachable
-} from "./chunk-MYP3UYWE.js";
-import "./chunk-CZNX6EUV.js";
+} from "./chunk-ZHIKNZLU.js";
+import "./chunk-HBIFE4XN.js";
 export {
   assert,
   assertBigInt,

package/dist/async.cjs

@@ -94,7 +94,7 @@ var once = async (target, event, opts) => {
   target.addEventListener(event, onSuccess, { once: true, signal: opts?.signal });
   target.addEventListener("error", onError, { once: true, signal: opts?.signal });
   if (opts?.signal) {
-    const signal = opts.signal;
+    const { signal } = opts;
     const abort = () => {
       deferred.reject(new Error("aborted"));
     };

package/dist/async.d.cts

@@ -25,7 +25,7 @@ declare class RateLimiter<T, Args extends unknown[]> {
     });
     request(...args: Args): Promise<T>;
 }
-declare const once: <T extends EventTarget, K extends string>(target: T, event: K, opts?: {
+declare const once: (target: EventTarget, event: string, opts?: {
     signal?: AbortSignal;
     timeout?: number;
 }) => Promise<void>;

package/dist/async.d.ts

@@ -25,7 +25,7 @@ declare class RateLimiter<T, Args extends unknown[]> {
     });
     request(...args: Args): Promise<T>;
 }
-declare const once: <T extends EventTarget, K extends string>(target: T, event: K, opts?: {
+declare const once: (target: EventTarget, event: string, opts?: {
     signal?: AbortSignal;
     timeout?: number;
 }) => Promise<void>;

package/dist/async.js

@@ -66,7 +66,7 @@ var once = async (target, event, opts) => {
   target.addEventListener(event, onSuccess, { once: true, signal: opts?.signal });
   target.addEventListener("error", onError, { once: true, signal: opts?.signal });
   if (opts?.signal) {
-    const signal = opts.signal;
+    const { signal } = opts;
     const abort = () => {
       deferred.reject(new Error("aborted"));
     };

package/dist/base58.js

@@ -1,10 +1,10 @@
 import {
   decode,
   encode
-} from "./chunk-UPA7KLTI.js";
-import "./chunk-D7RIA7SA.js";
-import "./chunk-MYP3UYWE.js";
-import "./chunk-CZNX6EUV.js";
+} from "./chunk-CGMSQQDO.js";
+import "./chunk-2KA626OL.js";
+import "./chunk-ZHIKNZLU.js";
+import "./chunk-HBIFE4XN.js";
 export {
   decode,
   encode

package/dist/bytes.js

@@ -4,9 +4,9 @@ import {
   encodeBytesWithCharset,
   hexToBytes,
   reverseBytes
-} from "./chunk-D7RIA7SA.js";
-import "./chunk-MYP3UYWE.js";
-import "./chunk-CZNX6EUV.js";
+} from "./chunk-2KA626OL.js";
+import "./chunk-ZHIKNZLU.js";
+import "./chunk-HBIFE4XN.js";
 export {
   bytesToHex,
   decodeBytesWithCharset,

package/dist/chainflip.cjs

@@ -0,0 +1,147 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/chainflip.ts
+var chainflip_exports = {};
+__export(chainflip_exports, {
+  assetConstants: () => assetConstants,
+  baseChainflipAssets: () => baseChainflipAssets,
+  chainConstants: () => chainConstants,
+  chainflipAssets: () => chainflipAssets,
+  chainflipChains: () => chainflipChains,
+  chainflipEvmChains: () => chainflipEvmChains,
+  chainflipNetworks: () => chainflipNetworks,
+  readAssetValue: () => readAssetValue,
+  rpcAssets: () => rpcAssets
+});
+module.exports = __toCommonJS(chainflip_exports);
+var chainflipAssets = [
+  "Usdc",
+  "Usdt",
+  "Flip",
+  "Dot",
+  "Eth",
+  "Btc",
+  "ArbUsdc",
+  "ArbEth",
+  "Sol",
+  "SolUsdc"
+];
+var rpcAssets = ["USDC", "USDT", "FLIP", "DOT", "ETH", "BTC", "SOL"];
+var baseChainflipAssets = chainflipAssets.filter(
+  (asset) => asset !== "Usdc"
+);
+var chainflipEvmChains = ["Ethereum", "Arbitrum"];
+var chainflipChains = [...chainflipEvmChains, "Bitcoin", "Polkadot", "Solana"];
+var chainflipNetworks = ["backspin", "sisyphos", "perseverance", "mainnet"];
+var readAssetValue = (value, asset) => {
+  const chainValues = value[assetConstants[asset].chain];
+  return chainValues[assetConstants[asset].rpcAsset];
+};
+var assetConstants = {
+  Eth: {
+    chain: "Ethereum",
+    rpcAsset: "ETH",
+    decimals: 18
+  },
+  Flip: {
+    chain: "Ethereum",
+    rpcAsset: "FLIP",
+    decimals: 18
+  },
+  Usdc: {
+    chain: "Ethereum",
+    rpcAsset: "USDC",
+    decimals: 6
+  },
+  Usdt: {
+    chain: "Ethereum",
+    rpcAsset: "USDT",
+    decimals: 6
+  },
+  Dot: {
+    chain: "Polkadot",
+    rpcAsset: "DOT",
+    decimals: 10
+  },
+  Btc: {
+    chain: "Bitcoin",
+    rpcAsset: "BTC",
+    decimals: 8
+  },
+  ArbUsdc: {
+    chain: "Arbitrum",
+    rpcAsset: "USDC",
+    decimals: 6
+  },
+  ArbEth: {
+    chain: "Arbitrum",
+    rpcAsset: "ETH",
+    decimals: 18
+  },
+  Sol: {
+    chain: "Solana",
+    rpcAsset: "SOL",
+    decimals: 9
+  },
+  SolUsdc: {
+    chain: "Solana",
+    rpcAsset: "USDC",
+    decimals: 6
+  }
+};
+var chainConstants = {
+  Ethereum: {
+    assets: ["Eth", "Flip", "Usdc", "Usdt"],
+    gasAsset: "Eth",
+    blockTimeSeconds: 12
+  },
+  Polkadot: {
+    assets: ["Dot"],
+    gasAsset: "Dot",
+    blockTimeSeconds: 6
+  },
+  Bitcoin: {
+    assets: ["Btc"],
+    gasAsset: "Btc",
+    blockTimeSeconds: 10 * 60
+  },
+  Arbitrum: {
+    assets: ["ArbUsdc", "ArbEth"],
+    gasAsset: "ArbEth",
+    blockTimeSeconds: 0.26
+  },
+  Solana: {
+    assets: ["Sol", "SolUsdc"],
+    gasAsset: "Sol",
+    blockTimeSeconds: 0.8
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  assetConstants,
+  baseChainflipAssets,
+  chainConstants,
+  chainflipAssets,
+  chainflipChains,
+  chainflipEvmChains,
+  chainflipNetworks,
+  readAssetValue,
+  rpcAssets
+});

package/dist/chainflip.d.cts

@@ -0,0 +1,99 @@
+declare const chainflipAssets: readonly ["Usdc", "Usdt", "Flip", "Dot", "Eth", "Btc", "ArbUsdc", "ArbEth", "Sol", "SolUsdc"];
+type ChainflipAsset = (typeof chainflipAssets)[number];
+declare const rpcAssets: readonly ["USDC", "USDT", "FLIP", "DOT", "ETH", "BTC", "SOL"];
+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"];
+type ChainflipChain = (typeof chainflipChains)[number];
+declare const chainflipNetworks: readonly ["backspin", "sisyphos", "perseverance", "mainnet"];
+type ChainflipNetwork = (typeof chainflipNetworks)[number];
+type AssetOfChain<C extends ChainflipChain> = (typeof chainConstants)[C]['assets'][number];
+type ChainAssetMap<T> = {
+    [C in ChainflipChain]: {
+        [A in (typeof assetConstants)[AssetOfChain<C>]['rpcAsset']]: T;
+    };
+};
+declare const readAssetValue: <T>(value: ChainAssetMap<T>, asset: ChainflipAsset) => T;
+declare const assetConstants: {
+    readonly Eth: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "ETH";
+        readonly decimals: 18;
+    };
+    readonly Flip: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "FLIP";
+        readonly decimals: 18;
+    };
+    readonly Usdc: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+    readonly Usdt: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "USDT";
+        readonly decimals: 6;
+    };
+    readonly Dot: {
+        readonly chain: "Polkadot";
+        readonly rpcAsset: "DOT";
+        readonly decimals: 10;
+    };
+    readonly Btc: {
+        readonly chain: "Bitcoin";
+        readonly rpcAsset: "BTC";
+        readonly decimals: 8;
+    };
+    readonly ArbUsdc: {
+        readonly chain: "Arbitrum";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+    readonly ArbEth: {
+        readonly chain: "Arbitrum";
+        readonly rpcAsset: "ETH";
+        readonly decimals: 18;
+    };
+    readonly Sol: {
+        readonly chain: "Solana";
+        readonly rpcAsset: "SOL";
+        readonly decimals: 9;
+    };
+    readonly SolUsdc: {
+        readonly chain: "Solana";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+};
+declare const chainConstants: {
+    readonly Ethereum: {
+        readonly assets: ["Eth", "Flip", "Usdc", "Usdt"];
+        readonly gasAsset: "Eth";
+        readonly blockTimeSeconds: 12;
+    };
+    readonly Polkadot: {
+        readonly assets: ["Dot"];
+        readonly gasAsset: "Dot";
+        readonly blockTimeSeconds: 6;
+    };
+    readonly Bitcoin: {
+        readonly assets: ["Btc"];
+        readonly gasAsset: "Btc";
+        readonly blockTimeSeconds: number;
+    };
+    readonly Arbitrum: {
+        readonly assets: ["ArbUsdc", "ArbEth"];
+        readonly gasAsset: "ArbEth";
+        readonly blockTimeSeconds: 0.26;
+    };
+    readonly Solana: {
+        readonly assets: ["Sol", "SolUsdc"];
+        readonly gasAsset: "Sol";
+        readonly blockTimeSeconds: 0.8;
+    };
+};
+
+export { type AssetOfChain, type BaseChainflipAsset, type ChainAssetMap, type ChainflipAsset, type ChainflipChain, type ChainflipEvmChain, type ChainflipNetwork, assetConstants, baseChainflipAssets, chainConstants, chainflipAssets, chainflipChains, chainflipEvmChains, chainflipNetworks, readAssetValue, rpcAssets };

package/dist/chainflip.d.ts

@@ -0,0 +1,99 @@
+declare const chainflipAssets: readonly ["Usdc", "Usdt", "Flip", "Dot", "Eth", "Btc", "ArbUsdc", "ArbEth", "Sol", "SolUsdc"];
+type ChainflipAsset = (typeof chainflipAssets)[number];
+declare const rpcAssets: readonly ["USDC", "USDT", "FLIP", "DOT", "ETH", "BTC", "SOL"];
+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"];
+type ChainflipChain = (typeof chainflipChains)[number];
+declare const chainflipNetworks: readonly ["backspin", "sisyphos", "perseverance", "mainnet"];
+type ChainflipNetwork = (typeof chainflipNetworks)[number];
+type AssetOfChain<C extends ChainflipChain> = (typeof chainConstants)[C]['assets'][number];
+type ChainAssetMap<T> = {
+    [C in ChainflipChain]: {
+        [A in (typeof assetConstants)[AssetOfChain<C>]['rpcAsset']]: T;
+    };
+};
+declare const readAssetValue: <T>(value: ChainAssetMap<T>, asset: ChainflipAsset) => T;
+declare const assetConstants: {
+    readonly Eth: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "ETH";
+        readonly decimals: 18;
+    };
+    readonly Flip: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "FLIP";
+        readonly decimals: 18;
+    };
+    readonly Usdc: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+    readonly Usdt: {
+        readonly chain: "Ethereum";
+        readonly rpcAsset: "USDT";
+        readonly decimals: 6;
+    };
+    readonly Dot: {
+        readonly chain: "Polkadot";
+        readonly rpcAsset: "DOT";
+        readonly decimals: 10;
+    };
+    readonly Btc: {
+        readonly chain: "Bitcoin";
+        readonly rpcAsset: "BTC";
+        readonly decimals: 8;
+    };
+    readonly ArbUsdc: {
+        readonly chain: "Arbitrum";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+    readonly ArbEth: {
+        readonly chain: "Arbitrum";
+        readonly rpcAsset: "ETH";
+        readonly decimals: 18;
+    };
+    readonly Sol: {
+        readonly chain: "Solana";
+        readonly rpcAsset: "SOL";
+        readonly decimals: 9;
+    };
+    readonly SolUsdc: {
+        readonly chain: "Solana";
+        readonly rpcAsset: "USDC";
+        readonly decimals: 6;
+    };
+};
+declare const chainConstants: {
+    readonly Ethereum: {
+        readonly assets: ["Eth", "Flip", "Usdc", "Usdt"];
+        readonly gasAsset: "Eth";
+        readonly blockTimeSeconds: 12;
+    };
+    readonly Polkadot: {
+        readonly assets: ["Dot"];
+        readonly gasAsset: "Dot";
+        readonly blockTimeSeconds: 6;
+    };
+    readonly Bitcoin: {
+        readonly assets: ["Btc"];
+        readonly gasAsset: "Btc";
+        readonly blockTimeSeconds: number;
+    };
+    readonly Arbitrum: {
+        readonly assets: ["ArbUsdc", "ArbEth"];
+        readonly gasAsset: "ArbEth";
+        readonly blockTimeSeconds: 0.26;
+    };
+    readonly Solana: {
+        readonly assets: ["Sol", "SolUsdc"];
+        readonly gasAsset: "Sol";
+        readonly blockTimeSeconds: 0.8;
+    };
+};
+
+export { type AssetOfChain, type BaseChainflipAsset, type ChainAssetMap, type ChainflipAsset, type ChainflipChain, type ChainflipEvmChain, type ChainflipNetwork, assetConstants, baseChainflipAssets, chainConstants, chainflipAssets, chainflipChains, chainflipEvmChains, chainflipNetworks, readAssetValue, rpcAssets };

package/dist/chainflip.js

@@ -0,0 +1,22 @@
+import {
+  assetConstants,
+  baseChainflipAssets,
+  chainConstants,
+  chainflipAssets,
+  chainflipChains,
+  chainflipEvmChains,
+  chainflipNetworks,
+  readAssetValue,
+  rpcAssets
+} from "./chunk-XFHVSV76.js";
+export {
+  assetConstants,
+  baseChainflipAssets,
+  chainConstants,
+  chainflipAssets,
+  chainflipChains,
+  chainflipEvmChains,
+  chainflipNetworks,
+  readAssetValue,
+  rpcAssets
+};

package/dist/{chunk-D7RIA7SA.js → chunk-2KA626OL.js}

@@ -1,6 +1,6 @@
 import {
   assert
-} from "./chunk-MYP3UYWE.js";
+} from "./chunk-ZHIKNZLU.js";
 
 // src/bytes.ts
 var bytesToHex = (input) => {

package/dist/{chunk-UPA7KLTI.js → chunk-CGMSQQDO.js}

@@ -1,7 +1,7 @@
 import {
   decodeBytesWithCharset,
   encodeBytesWithCharset
-} from "./chunk-D7RIA7SA.js";
+} from "./chunk-2KA626OL.js";
 
 // src/base58.ts
 var charset = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";

package/dist/{chunk-CZNX6EUV.js → chunk-HBIFE4XN.js}

@@ -9,6 +9,9 @@ var isObject = createIsGuard("object");
 var isUndefined = createIsGuard("undefined");
 var isNotNullish = (value) => value != null;
 var isNullish = (value) => value == null;
+var isTruthy = (value) => Boolean(value);
+var isFullfilled = (value) => value.status === "fulfilled";
+var isRejected = (value) => value.status === "rejected";
 
 export {
   isString,
@@ -19,5 +22,8 @@ export {
   isObject,
   isUndefined,
   isNotNullish,
-  isNullish
+  isNullish,
+  isTruthy,
+  isFullfilled,
+  isRejected
 };