@skate-org/amm-core-v2 0.4.0

package/dist/index.cjs

@@ -0,0 +1,659 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ActionBoxAddress: () => ActionBoxAddress,
+  BLOCK_EXPLORER: () => BLOCK_EXPLORER,
+  CHAIN: () => CHAIN,
+  CHAIN_MAP: () => CHAIN_MAP,
+  KERNEL_ACCOUNT_REGISTRY_Dev: () => KERNEL_ACCOUNT_REGISTRY_Dev,
+  KERNEL_EVENT_EMITTER_Dev: () => KERNEL_EVENT_EMITTER_Dev,
+  KERNEL_EVENT_EMITTER_Prod: () => KERNEL_EVENT_EMITTER_Prod,
+  KERNEL_EVENT_EMITTER_Staging: () => KERNEL_EVENT_EMITTER_Staging,
+  KERNEL_EXECUTOR_REGISTRY_Dev: () => KERNEL_EXECUTOR_REGISTRY_Dev,
+  KERNEL_MANAGER_Dev: () => KERNEL_MANAGER_Dev,
+  KERNEL_MANAGER_Prod: () => KERNEL_MANAGER_Prod,
+  KERNEL_MANAGER_Staging: () => KERNEL_MANAGER_Staging,
+  KERNEL_MESSAGE_BOX_Dev: () => KERNEL_MESSAGE_BOX_Dev,
+  KERNEL_POOL_IMPL_Dev: () => KERNEL_POOL_IMPL_Dev,
+  KERNEL_POOL_USDC_USDT_Dev: () => KERNEL_POOL_USDC_USDT_Dev,
+  KernelEventEmitterAddress: () => KernelEventEmitterAddress,
+  KernelManagerAddress: () => KernelManagerAddress,
+  PERIPHERY_DEV: () => PERIPHERY_DEV,
+  PERIPHERY_PROD: () => PERIPHERY_PROD,
+  PERIPHERY_STAGING: () => PERIPHERY_STAGING,
+  POOL_INFO_Dev: () => POOL_INFO_Dev,
+  POOL_INFO_Production: () => POOL_INFO_Production,
+  POOL_INFO_Staging: () => POOL_INFO_Staging,
+  PeripheryDeploymentFor: () => PeripheryDeploymentFor,
+  PeripheryEventEmitterAddress: () => PeripheryEventEmitterAddress,
+  PeripheryManagerAddress: () => PeripheryManagerAddress,
+  SdkError: () => SdkError,
+  SkateGatewayAddress: () => SkateGatewayAddress,
+  TaskPhase: () => TaskPhase,
+  VM: () => VM,
+  base58ToBytes32: () => base58ToBytes32,
+  base58ToHex: () => base58ToHex,
+  bufferFromBase58: () => bufferFromBase58,
+  bytes32HexRegex: () => bytes32HexRegex,
+  bytes32ToBase58: () => bytes32ToBase58,
+  bytes32ToEvmAddress: () => bytes32ToEvmAddress,
+  evmAddressToBytes32: () => evmAddressToBytes32,
+  fromBytes32Address: () => fromBytes32Address,
+  getAllPoolInfo: () => getAllPoolInfo,
+  getAllPoolKeys: () => getAllPoolKeys,
+  getBlockExplorer: () => getBlockExplorer,
+  getOtherTokensInPairs: () => getOtherTokensInPairs,
+  getPeripheryDetailsByKernelPoolAndChainId: () => getPeripheryDetailsByKernelPoolAndChainId,
+  getPoolInfoByKey: () => getPoolInfoByKey,
+  getSupportedChains: () => getSupportedChains,
+  getSupportedPairs: () => getSupportedPairs,
+  getSupportedTokens: () => getSupportedTokens,
+  hexToBase58: () => hexToBase58,
+  isHexString: () => isHexString,
+  isHexStringLoose: () => isHexStringLoose,
+  kernelPoolToPoolKey: () => kernelPoolToPoolKey,
+  normalizeMode: () => normalizeMode,
+  skateAdapter: () => skate_exports,
+  toBase58: () => toBase58,
+  toBytes32Address: () => toBytes32Address,
+  vmTypeFromChain: () => vmTypeFromChain
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/chain.ts
+var CHAIN = /* @__PURE__ */ ((CHAIN2) => {
+  CHAIN2[CHAIN2["SKATE"] = 5050] = "SKATE";
+  CHAIN2[CHAIN2["SOLANA"] = 901] = "SOLANA";
+  CHAIN2[CHAIN2["ECLIPSE"] = 902] = "ECLIPSE";
+  CHAIN2[CHAIN2["SUI"] = 1001] = "SUI";
+  CHAIN2[CHAIN2["BASE"] = 8453] = "BASE";
+  CHAIN2[CHAIN2["ARBITRUM"] = 42161] = "ARBITRUM";
+  CHAIN2[CHAIN2["BSC"] = 56] = "BSC";
+  CHAIN2[CHAIN2["MANTLE"] = 5e3] = "MANTLE";
+  CHAIN2[CHAIN2["OPTIMISM"] = 10] = "OPTIMISM";
+  CHAIN2[CHAIN2["ETHEREUM"] = 1] = "ETHEREUM";
+  CHAIN2[CHAIN2["HYPERLIQUID"] = 999] = "HYPERLIQUID";
+  CHAIN2[CHAIN2["PLUME"] = 98866] = "PLUME";
+  CHAIN2[CHAIN2["ZG"] = 16661] = "ZG";
+  CHAIN2[CHAIN2["MONAD"] = 143] = "MONAD";
+  CHAIN2[CHAIN2["MEGAETH"] = 4326] = "MEGAETH";
+  CHAIN2[CHAIN2["TEMPO"] = 4217] = "TEMPO";
+  return CHAIN2;
+})(CHAIN || {});
+var CHAIN_MAP = Object.entries(CHAIN).filter(([, value]) => typeof value === "number").reduce(
+  (map, [key, value]) => {
+    map[key] = value;
+    return map;
+  },
+  {}
+);
+
+// src/types/vm.ts
+var VM = /* @__PURE__ */ ((VM2) => {
+  VM2[VM2["EVM"] = 1] = "EVM";
+  VM2[VM2["TVM"] = 2] = "TVM";
+  VM2[VM2["SVM"] = 3] = "SVM";
+  VM2[VM2["SuiVM"] = 4] = "SuiVM";
+  return VM2;
+})(VM || {});
+var BLOCK_EXPLORER = /* @__PURE__ */ ((BLOCK_EXPLORER2) => {
+  BLOCK_EXPLORER2["SKATE"] = "https://scan.skatechain.org";
+  BLOCK_EXPLORER2["ECLIPSE"] = "https://eclipsescan.xyz";
+  BLOCK_EXPLORER2["SOLANA"] = "https://solscan.io";
+  BLOCK_EXPLORER2["SUI"] = "https://suiscan.xyz/mainnet";
+  BLOCK_EXPLORER2["BASE"] = "https://basescan.org";
+  BLOCK_EXPLORER2["ARBITRUM"] = "https://arbiscan.io";
+  BLOCK_EXPLORER2["MANTLE"] = "https://mantlescan.xyz";
+  BLOCK_EXPLORER2["OPTIMISM"] = "https://optimistic.etherscan.io";
+  BLOCK_EXPLORER2["ETHEREUM"] = "https://etherscan.io";
+  BLOCK_EXPLORER2["BSC"] = "https://bscscan.com";
+  BLOCK_EXPLORER2["HYPERLIQUID"] = "https://hyperscan.com";
+  BLOCK_EXPLORER2["PLUME"] = "https://explorer.plume.org";
+  BLOCK_EXPLORER2["ZG"] = "https://chainscan.0g.ai";
+  BLOCK_EXPLORER2["MONAD"] = "https://monadvision.com";
+  BLOCK_EXPLORER2["MEGAETH"] = "https://megaeth.blockscout.com";
+  BLOCK_EXPLORER2["TEMPO"] = "https://explore.tempo.xyz";
+  return BLOCK_EXPLORER2;
+})(BLOCK_EXPLORER || {});
+function getBlockExplorer(chain) {
+  switch (chain) {
+    case 5050 /* SKATE */:
+      return "https://scan.skatechain.org" /* SKATE */;
+    case 901 /* SOLANA */:
+      return "https://solscan.io" /* SOLANA */;
+    case 902 /* ECLIPSE */:
+      return "https://eclipsescan.xyz" /* ECLIPSE */;
+    case 1001 /* SUI */:
+      return "https://suiscan.xyz/mainnet" /* SUI */;
+    case 8453 /* BASE */:
+      return "https://basescan.org" /* BASE */;
+    case 42161 /* ARBITRUM */:
+      return "https://arbiscan.io" /* ARBITRUM */;
+    case 5e3 /* MANTLE */:
+      return "https://mantlescan.xyz" /* MANTLE */;
+    case 10 /* OPTIMISM */:
+      return "https://optimistic.etherscan.io" /* OPTIMISM */;
+    case 1 /* ETHEREUM */:
+      return "https://etherscan.io" /* ETHEREUM */;
+    case 56 /* BSC */:
+      return "https://bscscan.com" /* BSC */;
+    case 999 /* HYPERLIQUID */:
+      return "https://hyperscan.com" /* HYPERLIQUID */;
+    case 98866 /* PLUME */:
+      return "https://explorer.plume.org" /* PLUME */;
+    case 16661 /* ZG */:
+      return "https://chainscan.0g.ai" /* ZG */;
+    case 143 /* MONAD */:
+      return "https://monadvision.com" /* MONAD */;
+    case 4326 /* MEGAETH */:
+      return "https://megaeth.blockscout.com" /* MEGAETH */;
+    case 4217 /* TEMPO */:
+      return "https://explore.tempo.xyz" /* TEMPO */;
+    default:
+      return null;
+  }
+}
+function vmTypeFromChain(chainId) {
+  switch (chainId) {
+    case 5050 /* SKATE */:
+    case 8453 /* BASE */:
+    case 42161 /* ARBITRUM */:
+    case 5e3 /* MANTLE */:
+    case 10 /* OPTIMISM */:
+    case 1 /* ETHEREUM */:
+    case 56 /* BSC */:
+    case 999 /* HYPERLIQUID */:
+    case 98866 /* PLUME */:
+    case 16661 /* ZG */:
+    case 143 /* MONAD */:
+    case 4326 /* MEGAETH */:
+    case 4217 /* TEMPO */:
+      return 1 /* EVM */;
+    case 901 /* SOLANA */:
+    case 902 /* ECLIPSE */:
+      return 3 /* SVM */;
+    case 1001 /* SUI */:
+      return 4 /* SuiVM */;
+    default:
+      return null;
+  }
+}
+
+// src/types/mode.ts
+function normalizeMode(mode) {
+  if (typeof mode === "string") return { mode };
+  return { mode: mode.mode, config: mode.config };
+}
+
+// src/types/action.ts
+var TaskPhase = /* @__PURE__ */ ((TaskPhase2) => {
+  TaskPhase2["INDEX_ACTION"] = "INDEX_ACTION";
+  TaskPhase2["SETTLE_KERNEL"] = "SETTLE_KERNEL";
+  TaskPhase2["SUBMIT_EXECUTION"] = "SUBMIT_EXECUTION";
+  TaskPhase2["SETTLE_GATEWAY"] = "SETTLE_GATEWAY";
+  TaskPhase2["SETTLE_REFUND"] = "SETTLE_REFUND";
+  return TaskPhase2;
+})(TaskPhase || {});
+
+// src/deployment/kernel.ts
+var KERNEL_EXECUTOR_REGISTRY_Dev = "0x45F5e211B2CAeA14d5E5cB028923F8A5D7b1ab5d";
+var KERNEL_MESSAGE_BOX_Dev = "0xe3aC86bF5D9Ab5d9705b5e9187437e978397528B";
+var KERNEL_ACCOUNT_REGISTRY_Dev = "0xeD9e139CAcb439744277be5D7fbEe5aAF4DB8fA2";
+var KERNEL_MANAGER_Dev = "0x17B7207837e8884f7f687f1f4057751BDAf70a01";
+var KERNEL_EVENT_EMITTER_Dev = "0x8989b3ecb65f250ab7A0DC03589B0Cc8b8b04b81";
+var KERNEL_POOL_IMPL_Dev = "0x9BffA944Df7914621A7Cc638C9104C106c5C6846";
+var KERNEL_POOL_USDC_USDT_Dev = "0x2c23334eE3b030e6bacEDEDf7C511eEA08Cf7E7e";
+var KERNEL_MANAGER_Staging = "0xB32841DD65316F672eb07c63508f4b6841b6Aee4";
+var KERNEL_EVENT_EMITTER_Staging = "0x8f16B23A11378bE8573470e23f626b9a7e41B389";
+var KERNEL_MANAGER_Prod = "0x46887a1f9885300f4185499Ba48C248445EEcAb1";
+var KERNEL_EVENT_EMITTER_Prod = "0xC8615dcE472fD684D0FDcEC18013EaB402F61ba7";
+function KernelManagerAddress(mode = "PRODUCTION") {
+  switch (mode) {
+    case "PRODUCTION":
+      return KERNEL_MANAGER_Prod;
+    case "STAGING":
+      return KERNEL_MANAGER_Staging;
+    case "DEV":
+      return KERNEL_MANAGER_Dev;
+  }
+}
+function KernelEventEmitterAddress(mode = "PRODUCTION") {
+  switch (mode) {
+    case "PRODUCTION":
+      return KERNEL_EVENT_EMITTER_Prod;
+    case "STAGING":
+      return KERNEL_EVENT_EMITTER_Staging;
+    case "DEV":
+      return KERNEL_EVENT_EMITTER_Dev;
+  }
+}
+
+// src/deployment/periphery.ts
+var PERIPHERY_DEV = {
+  [42161 /* ARBITRUM */]: {
+    multicall: "0x3dCD7A136F0A49f3EFcC5E215793Fa1ce5c400Bf",
+    executorRegistry: "0xE84a60d66543ef8E2E162f66a7669692b01Ee145",
+    actionBox: "0x4309d3aE98c8A751fAc34C91536Ee860d9B8DcE1",
+    skateGateway: "0x63Ca920425f683138B9407171b51b8172421Ba50",
+    peripheryManager: "0x1120d6B34c4EB0CD49200aE9fBD2e4fb002d949f",
+    peripheryManagerImpl: "0x26F01bc73cB7422DB67BBDfAcd9C987Ae66bF3D3",
+    eventEmitter: "0xB301150AFA170816Ae18EC21e2A830Ddc7bBA1De",
+    peripheryPoolImpl: "0x803ed7fa8934D4fe51A276cA02506b585cdb3eb4"
+  }
+};
+var PERIPHERY_STAGING = {};
+var PERIPHERY_PROD = {};
+function PeripheryDeploymentFor(chain, mode = "PRODUCTION") {
+  const table = mode === "DEV" ? PERIPHERY_DEV : mode === "STAGING" ? PERIPHERY_STAGING : PERIPHERY_PROD;
+  return table[chain] ?? null;
+}
+function PeripheryManagerAddress(chain, mode = "PRODUCTION") {
+  return PeripheryDeploymentFor(chain, mode)?.peripheryManager ?? null;
+}
+function PeripheryEventEmitterAddress(chain, mode = "PRODUCTION") {
+  return PeripheryDeploymentFor(chain, mode)?.eventEmitter ?? null;
+}
+function SkateGatewayAddress(chain, mode = "PRODUCTION") {
+  return PeripheryDeploymentFor(chain, mode)?.skateGateway ?? null;
+}
+function ActionBoxAddress(chain, mode = "PRODUCTION") {
+  return PeripheryDeploymentFor(chain, mode)?.actionBox ?? null;
+}
+
+// src/deployment/aggregated/dev.ts
+var POOL_INFO_Dev = {
+  USDC_USDT: {
+    kernelPool: KERNEL_POOL_USDC_USDT_Dev,
+    token0: "USDC",
+    token1: "USDT",
+    feeBps: 1,
+    peripheryInfo: {
+      [42161 /* ARBITRUM */]: {
+        token0: {
+          address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+          symbol: "USDC",
+          isNative: false,
+          decimal: 6,
+          chainId: 42161 /* ARBITRUM */
+        },
+        token1: {
+          address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+          symbol: "USDT",
+          isNative: false,
+          decimal: 6,
+          chainId: 42161 /* ARBITRUM */
+        },
+        address: "0x0433CCB013a590eA4231aAC9ddf05bb753c14127",
+        chain: "ARBITRUM"
+      }
+    }
+  }
+};
+
+// src/deployment/aggregated/staging.ts
+var POOL_INFO_Staging = {};
+
+// src/deployment/aggregated/production.ts
+var POOL_INFO_Production = {};
+
+// src/deployment/aggregated/retrieval.ts
+function getAllPoolInfo(mode = "PRODUCTION") {
+  switch (mode) {
+    case "PRODUCTION":
+      return POOL_INFO_Production;
+    case "STAGING":
+      return POOL_INFO_Staging;
+    case "DEV":
+      return POOL_INFO_Dev;
+  }
+}
+function getAllPoolKeys(mode = "PRODUCTION") {
+  return Object.keys(getAllPoolInfo(mode));
+}
+function getPoolInfoByKey(key, mode = "PRODUCTION") {
+  return getAllPoolInfo(mode)[key] ?? null;
+}
+function getSupportedChains(mode = "PRODUCTION") {
+  const poolInfo = getAllPoolInfo(mode);
+  const supportedChains = /* @__PURE__ */ new Set();
+  for (const poolData of Object.values(poolInfo)) {
+    for (const chainId of Object.keys(poolData.peripheryInfo)) {
+      supportedChains.add(Number(chainId));
+    }
+  }
+  return Array.from(supportedChains).sort((a, b) => a - b);
+}
+function getSupportedPairs(chainId, mode = "PRODUCTION") {
+  const poolInfo = getAllPoolInfo(mode);
+  const supportedPairs = [];
+  for (const [poolKey, poolData] of Object.entries(poolInfo)) {
+    const peripheryData = poolData.peripheryInfo[chainId];
+    if (peripheryData) {
+      supportedPairs.push({
+        token0: peripheryData.token0,
+        token1: peripheryData.token1,
+        poolKey
+      });
+    }
+  }
+  return supportedPairs;
+}
+function getSupportedTokens(chainId, mode = "PRODUCTION") {
+  const supportedPairs = getSupportedPairs(chainId, mode);
+  const tokens = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { token0, token1 } of supportedPairs) {
+    for (const t of [token0, token1]) {
+      const key = t.address.toLowerCase();
+      if (!seen.has(key)) {
+        seen.add(key);
+        tokens.push(t);
+      }
+    }
+  }
+  return tokens;
+}
+function getOtherTokensInPairs(chainId, tokenAddress, mode = "PRODUCTION") {
+  const supportedPairs = getSupportedPairs(chainId, mode);
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  const needle = tokenAddress.toLowerCase();
+  for (const { token0, token1 } of supportedPairs) {
+    let other = null;
+    if (token0.address.toLowerCase() === needle) other = token1;
+    else if (token1.address.toLowerCase() === needle) other = token0;
+    if (other && !seen.has(other.address.toLowerCase())) {
+      seen.add(other.address.toLowerCase());
+      result.push(other);
+    }
+  }
+  return result;
+}
+function kernelPoolToPoolKey(kernelPool, mode = "PRODUCTION") {
+  const info = getAllPoolInfo(mode);
+  const lower = kernelPool.toLowerCase();
+  for (const [key, poolData] of Object.entries(info)) {
+    if (poolData.kernelPool.toLowerCase() === lower) return key;
+  }
+  throw new Error(`${mode} kernelPoolToPoolKey()::Unknown kernelPool ${kernelPool}`);
+}
+function getPeripheryDetailsByKernelPoolAndChainId(kernelPool, chainId, mode = "PRODUCTION") {
+  const poolKey = kernelPoolToPoolKey(kernelPool, mode);
+  const info = getAllPoolInfo(mode);
+  return info[poolKey]?.peripheryInfo[chainId] ?? null;
+}
+
+// src/adapter/skate.ts
+var skate_exports = {};
+__export(skate_exports, {
+  base58ToBytes32: () => base58ToBytes32,
+  base58ToHex: () => base58ToHex,
+  bufferFromBase58: () => bufferFromBase58,
+  bytes32HexRegex: () => bytes32HexRegex,
+  bytes32ToBase58: () => bytes32ToBase58,
+  bytes32ToEvmAddress: () => bytes32ToEvmAddress,
+  evmAddressToBytes32: () => evmAddressToBytes32,
+  fromBytes32Address: () => fromBytes32Address,
+  hexToBase58: () => hexToBase58,
+  isHexString: () => isHexString,
+  isHexStringLoose: () => isHexStringLoose,
+  toBase58: () => toBase58,
+  toBytes32Address: () => toBytes32Address
+});
+
+// src/utils/bs58.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base(ALPHABET) {
+  if (ALPHABET.length >= 255) throw new TypeError("Alphabet too long");
+  const BASE_MAP = new Uint8Array(256).fill(255);
+  for (let i = 0; i < ALPHABET.length; i++) {
+    const xc = ALPHABET.charCodeAt(i);
+    if (BASE_MAP[xc] !== 255) throw new TypeError(ALPHABET.charAt(i) + " is ambiguous");
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET.length;
+  const LEADER = ALPHABET.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array) {
+    } else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) throw new TypeError("Expected Uint8Array");
+    if (source.length === 0) return "";
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) throw new Error("Non-zero carry");
+      length = i;
+      pbegin++;
+    }
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) it2++;
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) str += ALPHABET.charAt(b58[it2]);
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") throw new TypeError("Expected String");
+    if (source.length === 0) return new Uint8Array();
+    let psz = 0;
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    const size = (source.length - psz) * FACTOR + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    while (psz < source.length) {
+      const charCode = source.charCodeAt(psz);
+      if (charCode > 255) return;
+      let carry = BASE_MAP[charCode];
+      if (carry === 255) return;
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) throw new Error("Non-zero carry");
+      length = i;
+      psz++;
+    }
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) it4++;
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) vch[j++] = b256[it4++];
+    return vch;
+  }
+  function decode(source) {
+    const buffer = decodeUnsafe(source);
+    if (buffer) return buffer;
+    throw new Error("Non-base" + BASE + " character");
+  }
+  return { encode, decode, decodeUnsafe };
+}
+var codec = base(BASE58_ALPHABET);
+var bs58Encode = codec.encode;
+var bs58Decode = codec.decode;
+
+// src/adapter/skate.ts
+function base58ToBytes32(base58Str) {
+  const decoded = bs58Decode(base58Str);
+  const addressBytes = new Uint8Array(32);
+  const startPos = Math.max(0, 32 - decoded.length);
+  addressBytes.set(decoded.slice(-32), startPos);
+  return "0x" + Buffer.from(addressBytes).toString("hex").toLowerCase();
+}
+function base58ToHex(base58Str) {
+  const decoded = bs58Decode(base58Str);
+  return `0x${Buffer.from(decoded).toString("hex").toLowerCase()}`;
+}
+function hexToBase58(hexString) {
+  return bs58Encode(Buffer.from(hexString.slice(2), "hex"));
+}
+function bytes32ToBase58(hexStr) {
+  const hexWithoutPrefix = hexStr.startsWith("0x") ? hexStr.slice(2) : hexStr;
+  const addressBytes = Buffer.from(hexWithoutPrefix, "hex");
+  const firstNonZero = addressBytes.findIndex((byte) => byte !== 0);
+  const trimmed = firstNonZero < 0 ? addressBytes : addressBytes.subarray(firstNonZero);
+  return bs58Encode(trimmed);
+}
+var bytes32HexRegex = /^(?:0x)?[0-9a-fA-F]{64}$/;
+function isHexString(str) {
+  return typeof str === "string" && /^0x[0-9a-fA-F]+$/.test(str);
+}
+function isHexStringLoose(str) {
+  return typeof str === "string" && /^(?:0x)?[0-9a-fA-F]+$/.test(str);
+}
+function evmAddressToBytes32(address) {
+  if (!address.startsWith("0x") && !address.startsWith("0X")) {
+    throw new TypeError(`evmAddressToBytes32: expected 0x-prefixed address, got "${address}"`);
+  }
+  return `0x${BigInt(address).toString(16).padStart(64, "0")}`.toLowerCase();
+}
+function bytes32ToEvmAddress(bytes32) {
+  const userBigInt = BigInt(bytes32);
+  const addressBigInt = userBigInt & BigInt("0xffffffffffffffffffffffffffffffffffffffff");
+  return `0x${addressBigInt.toString(16).padStart(40, "0")}`.toLowerCase();
+}
+function toBase58(buffer) {
+  return bs58Encode(buffer);
+}
+function bufferFromBase58(base58String) {
+  return Buffer.from(bs58Decode(base58String));
+}
+function toBytes32Address(rawAddress, vmType) {
+  switch (vmType) {
+    case 1 /* EVM */:
+      return evmAddressToBytes32(rawAddress);
+    case 3 /* SVM */:
+      return base58ToBytes32(rawAddress);
+    case 4 /* SuiVM */:
+      if (!bytes32HexRegex.test(rawAddress)) {
+        throw new TypeError(`toBytes32Address(SuiVM): expected 64-hex-char address, got "${rawAddress}"`);
+      }
+      return rawAddress;
+    default:
+      throw new Error(`toBytes32Address():Unsupported vmType=${vmType}`);
+  }
+}
+function fromBytes32Address(bytes32Address, vmType) {
+  switch (vmType) {
+    case 1 /* EVM */:
+      return bytes32ToEvmAddress(bytes32Address);
+    case 3 /* SVM */:
+      return bytes32ToBase58(bytes32Address);
+    case 4 /* SuiVM */:
+      return bytes32Address;
+    default:
+      throw new Error(`fromBytes32Address():Unsupported vmType=${vmType}`);
+  }
+}
+
+// src/errors.ts
+var SdkError = class extends Error {
+  name = "SdkError";
+  constructor(message, options) {
+    super(message, options);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ActionBoxAddress,
+  BLOCK_EXPLORER,
+  CHAIN,
+  CHAIN_MAP,
+  KERNEL_ACCOUNT_REGISTRY_Dev,
+  KERNEL_EVENT_EMITTER_Dev,
+  KERNEL_EVENT_EMITTER_Prod,
+  KERNEL_EVENT_EMITTER_Staging,
+  KERNEL_EXECUTOR_REGISTRY_Dev,
+  KERNEL_MANAGER_Dev,
+  KERNEL_MANAGER_Prod,
+  KERNEL_MANAGER_Staging,
+  KERNEL_MESSAGE_BOX_Dev,
+  KERNEL_POOL_IMPL_Dev,
+  KERNEL_POOL_USDC_USDT_Dev,
+  KernelEventEmitterAddress,
+  KernelManagerAddress,
+  PERIPHERY_DEV,
+  PERIPHERY_PROD,
+  PERIPHERY_STAGING,
+  POOL_INFO_Dev,
+  POOL_INFO_Production,
+  POOL_INFO_Staging,
+  PeripheryDeploymentFor,
+  PeripheryEventEmitterAddress,
+  PeripheryManagerAddress,
+  SdkError,
+  SkateGatewayAddress,
+  TaskPhase,
+  VM,
+  base58ToBytes32,
+  base58ToHex,
+  bufferFromBase58,
+  bytes32HexRegex,
+  bytes32ToBase58,
+  bytes32ToEvmAddress,
+  evmAddressToBytes32,
+  fromBytes32Address,
+  getAllPoolInfo,
+  getAllPoolKeys,
+  getBlockExplorer,
+  getOtherTokensInPairs,
+  getPeripheryDetailsByKernelPoolAndChainId,
+  getPoolInfoByKey,
+  getSupportedChains,
+  getSupportedPairs,
+  getSupportedTokens,
+  hexToBase58,
+  isHexString,
+  isHexStringLoose,
+  kernelPoolToPoolKey,
+  normalizeMode,
+  skateAdapter,
+  toBase58,
+  toBytes32Address,
+  vmTypeFromChain
+});
+//# sourceMappingURL=index.cjs.map