@flapsdk/vault-runtime 0.1.0

package/host.js

@@ -0,0 +1,871 @@
+import { erc20Abi, formatUnits, parseUnits } from 'viem';
+export { erc20Abi } from 'viem';
+import Decimal from 'decimal.js';
+
+// src/sdk/erc20.ts
+var standardErc20Abi = erc20Abi;
+function shortenAddress(raw, start = 6, end = 4) {
+  if (!raw) return "";
+  if (raw.length <= start + end) return raw;
+  return `${raw.slice(0, start)}...${raw.slice(-end)}`;
+}
+function formatTokenAmount(value, decimals = 18, precision = 4) {
+  if (value === void 0 || value === null) return "-";
+  const raw = typeof value === "bigint" ? formatUnits(value, decimals) : String(value);
+  return new Decimal(raw).toDecimalPlaces(precision, Decimal.ROUND_DOWN).toString();
+}
+function parseTokenAmount(value, decimals = 18) {
+  if (!/^\d*(\.\d*)?$/.test(value.trim())) {
+    throw new Error("Invalid decimal amount.");
+  }
+  return parseUnits(value || "0", decimals);
+}
+function formatPercentBps(value, precision = 2) {
+  if (value === void 0 || value === null) return "-";
+  return `${new Decimal(String(value)).div(100).toDecimalPlaces(precision).toString()}%`;
+}
+function formatCountdown(targetTimeMs) {
+  if (!targetTimeMs) return "-";
+  const diff = Math.max(0, targetTimeMs - Date.now());
+  const totalSeconds = Math.floor(diff / 1e3);
+  const hours = Math.floor(totalSeconds / 3600);
+  const minutes = Math.floor(totalSeconds % 3600 / 60);
+  const seconds = totalSeconds % 60;
+  if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`;
+  return `${minutes}m ${seconds}s`;
+}
+
+// src/sdk/hostRuntimeConfig.ts
+var taxVaultHostChains = {
+  56: {
+    portal: "0xe2ce6ab80874fa9fa2aae65d277dd6b8e65c9de0",
+    taxTokenHelperAddress: "0x53841c73217735F37BC1775538b03b23feFD8346",
+    vaultPortal: "0x90497450f2a706f1951b5bdda52B4E5d16f34C06",
+    wrappedNativeTokenAddress: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+    giftVaultFactory: "0x025549F52B03cF36f9e1a337c02d3AA7Af66ab32",
+    hostChainSlug: "bnb",
+    ipfsGateway: "https://gateway.pinata.cloud"
+  },
+  97: {
+    portal: "0x5bEacaF7ABCbB3aB280e80D007FD31fcE26510e9",
+    taxTokenHelperAddress: "0xD64441e5FcD02D342B8cf6eBA10Ef6E40d0dA90f",
+    vaultPortal: "0x027e3704fC5C16522e9393d04C60A3ac5c0d775f",
+    wrappedNativeTokenAddress: "0xae13d989daC2f0dEbFf460aC112a837C89BAa7cd",
+    giftVaultFactory: "0xa02DA44D67DB6D692efa7f751b5952bd670d5326",
+    hostChainSlug: "bnb-testnet",
+    ipfsGateway: "https://gateway.pinata.cloud"
+  }
+};
+function getTaxVaultHostChainConfig(chainId) {
+  return taxVaultHostChains[chainId];
+}
+
+// src/sdk/taxInfo.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+function getTupleField(data, name, index) {
+  if (!data) return void 0;
+  const record = data;
+  const tuple = data;
+  return record[name] ?? tuple[index];
+}
+function isValidAddress(value) {
+  return Boolean(value && /^0x[a-fA-F0-9]{40}$/.test(value));
+}
+function normalizeAddress(value) {
+  return isValidAddress(value) ? value : void 0;
+}
+function isSameAddress(a, b) {
+  return Boolean(a && b && a.toLowerCase() === b.toLowerCase());
+}
+function toNumber(value, fallback = 0) {
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "number") return Number.isFinite(value) ? value : fallback;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : fallback;
+  }
+  return fallback;
+}
+function toBigInt(value, fallback = 0n) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number" && Number.isFinite(value)) return BigInt(Math.trunc(value));
+  if (typeof value === "string" && value.trim()) {
+    try {
+      return BigInt(value);
+    } catch {
+      return fallback;
+    }
+  }
+  return fallback;
+}
+function toBooleanOrNull(value) {
+  if (typeof value === "boolean") return value;
+  if (value === null || value === void 0) return null;
+  return Boolean(value);
+}
+function toAddressOrNull(value) {
+  return typeof value === "string" && isValidAddress(value) ? value : null;
+}
+function toStringOrUndefined(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function parsePortalTokenInfo(tokenData) {
+  if (!tokenData) return null;
+  const status = toNumber(getTupleField(tokenData, "status", 0));
+  const taxRateRaw = toBigInt(getTupleField(tokenData, "taxRate", 12));
+  const quoteTokenAddress = toAddressOrNull(getTupleField(tokenData, "quoteTokenAddress", 9)) ?? ZERO_ADDRESS;
+  return {
+    exists: status !== 0,
+    isTaxToken: taxRateRaw > 0n,
+    taxRate: Number(taxRateRaw),
+    taxRateRaw,
+    quoteTokenAddress,
+    status,
+    tokenVersion: toNumber(getTupleField(tokenData, "tokenVersion", 4))
+  };
+}
+function parseFeeVaultInfo(vaultInfo) {
+  if (!vaultInfo) return null;
+  return {
+    addr: toAddressOrNull(getTupleField(vaultInfo, "addr", 0)),
+    factory: toAddressOrNull(getTupleField(vaultInfo, "factory", 1)),
+    riskLevel: toNumber(getTupleField(vaultInfo, "riskLevel", 2)),
+    isOfficialVault: toBooleanOrNull(getTupleField(vaultInfo, "isOfficialVault", 3)),
+    isVault: toBooleanOrNull(getTupleField(vaultInfo, "isVault", 4)),
+    isAIConsumer: toBooleanOrNull(getTupleField(vaultInfo, "isAIConsumer", 5))
+  };
+}
+function parseTaxTokenInfo(taxInfo, taxInfoV2, options = {}) {
+  if (!taxInfo) return null;
+  const quoteToken = toAddressOrNull(getTupleField(taxInfo, "quoteToken", 11)) ?? ZERO_ADDRESS;
+  const rawDividendToken = toAddressOrNull(getTupleField(taxInfoV2, "dividendToken", 11)) ?? quoteToken;
+  const dividendToken = quoteToken === ZERO_ADDRESS && rawDividendToken === ZERO_ADDRESS && options.wrappedNativeTokenAddress ? options.wrappedNativeTokenAddress : rawDividendToken;
+  return {
+    marketBps: toNumber(getTupleField(taxInfo, "marketBps", 0)),
+    deflationBps: toNumber(getTupleField(taxInfo, "deflationBps", 1)),
+    lpBps: toNumber(getTupleField(taxInfo, "lpBps", 2)),
+    dividendBps: toNumber(getTupleField(taxInfo, "dividendBps", 3)),
+    feeRate: toNumber(getTupleField(taxInfo, "feeRate", 4)),
+    buyTaxRate: taxInfoV2 ? toNumber(getTupleField(taxInfoV2, "buyTaxRate", 4)) : void 0,
+    sellTaxRate: taxInfoV2 ? toNumber(getTupleField(taxInfoV2, "sellTaxRate", 5)) : void 0,
+    burntTokenAmount: toBigInt(getTupleField(taxInfo, "burntTokenAmount", 5)),
+    totalQuoteSentToDividend: toBigInt(getTupleField(taxInfo, "totalQuoteSentToDividend", 6)),
+    totalQuoteAddedToLiquidity: toBigInt(getTupleField(taxInfo, "totalQuoteAddedToLiquidity", 7)),
+    totalTokenAddedToLiquidity: toBigInt(getTupleField(taxInfo, "totalTokenAddedToLiquidity", 8)),
+    totalQuoteSentToMarketing: toBigInt(getTupleField(taxInfo, "totalQuoteSentToMarketing", 9)),
+    marketingWallet: toAddressOrNull(getTupleField(taxInfo, "marketingWallet", 10)) ?? ZERO_ADDRESS,
+    dividendToken,
+    quoteToken,
+    minimumShareBalance: toBigInt(getTupleField(taxInfo, "minimumShareBalance", 12)),
+    vaultInfo: parseFeeVaultInfo(getTupleField(taxInfoV2, "vaultInfo", 14))
+  };
+}
+function parseVaultPortalInfo(vaultData) {
+  if (!vaultData) return null;
+  const found = Boolean(getTupleField(vaultData, "found", 0));
+  const info = getTupleField(vaultData, "info", 1);
+  if (!found || !info) return { found: false };
+  return {
+    found: true,
+    vault: toAddressOrNull(getTupleField(info, "vault", 0)) ?? ZERO_ADDRESS,
+    vaultFactory: toAddressOrNull(getTupleField(info, "vaultFactory", 1)) ?? ZERO_ADDRESS,
+    description: toStringOrUndefined(getTupleField(info, "description", 2)),
+    isOfficial: Boolean(getTupleField(info, "isOfficial", 3)),
+    riskLevel: toNumber(getTupleField(info, "riskLevel", 4))
+  };
+}
+function resolveManifestBinding(manifest, input) {
+  const bindings = manifest.match.bindings;
+  if (!bindings.length) return null;
+  const resolveUnique = (candidates) => {
+    if (candidates.length === 1) return candidates[0];
+    return null;
+  };
+  if (input.chainId && input.factoryAddress) {
+    return resolveUnique(bindings.filter((binding) => binding.chainId === input.chainId && isSameAddress(binding.factoryAddress, input.factoryAddress)));
+  }
+  if (input.chainId) {
+    return resolveUnique(bindings.filter((binding) => binding.chainId === input.chainId));
+  }
+  if (input.factoryAddress) {
+    return resolveUnique(bindings.filter((binding) => isSameAddress(binding.factoryAddress, input.factoryAddress)));
+  }
+  return null;
+}
+function isManifestRuntimeMatch(manifest, input) {
+  if (!input.chainId || !input.factoryAddress) return false;
+  const matchingBinding = resolveManifestBinding(manifest, input);
+  if (!matchingBinding) return false;
+  return matchingBinding.chainId === input.chainId && isSameAddress(matchingBinding.factoryAddress, input.factoryAddress);
+}
+function isVaultBindingMatch(binding, input) {
+  if (!input.chainId || binding.chainId !== input.chainId) return false;
+  if (!input.factoryAddress || !isSameAddress(binding.factoryAddress, input.factoryAddress)) return false;
+  return true;
+}
+function resolveVaultBinding(bindings, input) {
+  return bindings.find((binding) => isVaultBindingMatch(binding, input)) ?? null;
+}
+function resolveFeeMode(taxInfo, giftVaultFactory) {
+  if (!taxInfo) return "unknown";
+  const marketBps = toNumber(getTupleField(taxInfo, "marketBps", 0));
+  const dividendBps = toNumber(getTupleField(taxInfo, "dividendBps", 3));
+  if (dividendBps > 0) return "holder";
+  if (marketBps <= 0) return "unknown";
+  const parsedVaultInfo = "vaultInfo" in Object(taxInfo) ? taxInfo.vaultInfo : parseFeeVaultInfo(getTupleField(taxInfo, "vaultInfo", 14));
+  if (parsedVaultInfo?.isVault === true) {
+    return isSameAddress(parsedVaultInfo.factory, giftVaultFactory) ? "gift" : "unknown";
+  }
+  return "creator";
+}
+function resolveTaxInfoRenderSurface({
+  tokenInfo,
+  taxInfo,
+  hasTaxVaults = false,
+  isNonTaxFeeToken = false
+}) {
+  if (!tokenInfo?.exists) return "unavailable";
+  if (!tokenInfo.isTaxToken) return isNonTaxFeeToken ? "feeinfo" : "unavailable";
+  if (taxInfo?.marketBps === 1e4 && hasTaxVaults) return "vault-taxinfo";
+  return "standard-taxinfo";
+}
+function resolveTokenMarketPhase(tokenInfo) {
+  if (!tokenInfo?.exists) return "unknown";
+  return tokenInfo.status >= 2 ? "dex-listed" : "internal-market";
+}
+function isCustomVaultTaxToken(tokenInfo) {
+  return Boolean(tokenInfo?.exists && tokenInfo.isTaxToken);
+}
+function isActionAvailableForPhase(stage, marketPhase = "unknown") {
+  if (stage === "read-only") return false;
+  if (stage === "both") return true;
+  if (marketPhase === "unknown") return false;
+  return stage === marketPhase;
+}
+function createTaxInfoHostContext({
+  tokenInfo,
+  taxInfo,
+  vaultInfo,
+  feeMode,
+  giftVaultFactory,
+  hasTaxVaults,
+  vaultType,
+  copyScope = "tax"
+}) {
+  const resolvedFeeMode = feeMode ?? resolveFeeMode(taxInfo, giftVaultFactory);
+  const renderSurface = resolveTaxInfoRenderSurface({
+    tokenInfo,
+    taxInfo,
+    hasTaxVaults: hasTaxVaults ?? Boolean(vaultInfo?.found),
+    isNonTaxFeeToken: copyScope === "fee"
+  });
+  const marketPhase = resolveTokenMarketPhase(tokenInfo);
+  return {
+    tokenInfo: tokenInfo ?? void 0,
+    taxInfo: taxInfo ?? null,
+    vaultInfo: vaultInfo ?? null,
+    feeMode: resolvedFeeMode,
+    renderSurface,
+    vaultType,
+    copyScope,
+    isListed: tokenInfo ? tokenInfo.status >= 2 : void 0,
+    marketPhase
+  };
+}
+function readTaxVaultHostContext(host) {
+  const tokenInfo = host?.tokenInfo;
+  const marketPhase = host?.marketPhase ?? resolveTokenMarketPhase(tokenInfo);
+  const isListed = host?.isListed ?? Boolean(tokenInfo && tokenInfo.status >= 2);
+  const isTaxToken = tokenInfo?.isTaxToken === true;
+  return {
+    tokenInfo,
+    taxInfo: host?.taxInfo ?? null,
+    vaultInfo: host?.vaultInfo ?? null,
+    feeMode: host?.feeMode ?? "unknown",
+    renderSurface: host?.renderSurface ?? "unavailable",
+    vaultType: host?.vaultType,
+    copyScope: host?.copyScope ?? "tax",
+    marketPhase,
+    isListed,
+    isTaxToken,
+    isSupportedCustomVaultToken: isCustomVaultTaxToken(tokenInfo)
+  };
+}
+
+// src/sdk/hostRead.ts
+var portalAbi = [
+  {
+    name: "getTokenV7",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "", type: "address" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "status", type: "uint8" },
+          { name: "reserve", type: "uint256" },
+          { name: "circulatingSupply", type: "uint256" },
+          { name: "price", type: "uint256" },
+          { name: "tokenVersion", type: "uint8" },
+          { name: "r", type: "uint256" },
+          { name: "h", type: "uint256" },
+          { name: "k", type: "uint256" },
+          { name: "dexSupplyThresh", type: "uint256" },
+          { name: "quoteTokenAddress", type: "address" },
+          { name: "nativeToQuoteSwapEnabled", type: "bool" },
+          { name: "extensionID", type: "bytes32" },
+          { name: "taxRate", type: "uint256" },
+          { name: "pool", type: "address" },
+          { name: "progress", type: "uint256" },
+          { name: "lpFeeProfile", type: "uint8" },
+          { name: "dexId", type: "uint8" }
+        ]
+      }
+    ]
+  }
+];
+var taxTokenHelperAbi = [
+  {
+    name: "getTaxTokenInfo",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "taxToken", type: "address" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "marketBps", type: "uint16" },
+          { name: "deflationBps", type: "uint16" },
+          { name: "lpBps", type: "uint16" },
+          { name: "dividendBps", type: "uint16" },
+          { name: "feeRate", type: "uint16" },
+          { name: "burntTokenAmount", type: "uint256" },
+          { name: "totalQuoteSentToDividend", type: "uint256" },
+          { name: "totalQuoteAddedToLiquidity", type: "uint256" },
+          { name: "totalTokenAddedToLiquidity", type: "uint256" },
+          { name: "totalQuoteSentToMarketing", type: "uint256" },
+          { name: "marketingWallet", type: "address" },
+          { name: "quoteToken", type: "address" },
+          { name: "minimumShareBalance", type: "uint256" }
+        ]
+      }
+    ]
+  },
+  {
+    name: "getTaxTokenInfoV2",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "taxToken", type: "address" }],
+    outputs: [
+      {
+        type: "tuple",
+        components: [
+          { name: "marketBps", type: "uint16" },
+          { name: "deflationBps", type: "uint16" },
+          { name: "lpBps", type: "uint16" },
+          { name: "dividendBps", type: "uint16" },
+          { name: "buyTaxRate", type: "uint16" },
+          { name: "sellTaxRate", type: "uint16" },
+          { name: "burntTokenAmount", type: "uint256" },
+          { name: "totalQuoteSentToDividend", type: "uint256" },
+          { name: "totalQuoteAddedToLiquidity", type: "uint256" },
+          { name: "totalTokenAddedToLiquidity", type: "uint256" },
+          { name: "totalQuoteSentToMarketing", type: "uint256" },
+          { name: "dividendToken", type: "address" },
+          { name: "quoteToken", type: "address" },
+          { name: "minimumShareBalance", type: "uint256" },
+          {
+            name: "vaultInfo",
+            type: "tuple",
+            components: [
+              { name: "addr", type: "address" },
+              { name: "factory", type: "address" },
+              { name: "riskLevel", type: "uint8" },
+              { name: "isOfficialVault", type: "bool" },
+              { name: "isVault", type: "bool" },
+              { name: "isAIConsumer", type: "bool" }
+            ]
+          }
+        ]
+      }
+    ]
+  }
+];
+var vaultPortalAbi = [
+  {
+    name: "tryGetVault",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "taxToken", type: "address" }],
+    outputs: [
+      { name: "found", type: "bool" },
+      {
+        name: "info",
+        type: "tuple",
+        components: [
+          { name: "vault", type: "address" },
+          { name: "vaultFactory", type: "address" },
+          { name: "description", type: "string" },
+          { name: "isOfficial", type: "bool" },
+          { name: "riskLevel", type: "uint8" }
+        ]
+      }
+    ]
+  }
+];
+async function readErc20Symbol(publicClient, address) {
+  try {
+    const symbol = await publicClient.readContract({
+      address,
+      abi: erc20Abi,
+      functionName: "symbol"
+    });
+    return typeof symbol === "string" && symbol.trim() ? symbol.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readErc20Name(publicClient, address) {
+  try {
+    const name = await publicClient.readContract({
+      address,
+      abi: erc20Abi,
+      functionName: "name"
+    });
+    return typeof name === "string" && name.trim() ? name.trim() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function readErc20Decimals(publicClient, address) {
+  try {
+    const decimals = await publicClient.readContract({
+      address,
+      abi: erc20Abi,
+      functionName: "decimals"
+    });
+    return typeof decimals === "number" ? decimals : 18;
+  } catch {
+    return 18;
+  }
+}
+async function resolvePaymentToken(publicClient, tokenInfo) {
+  const quoteTokenAddress = tokenInfo.quoteTokenAddress;
+  if (!quoteTokenAddress) return void 0;
+  if (quoteTokenAddress === ZERO_ADDRESS) {
+    const nativeCurrency = publicClient.chain?.nativeCurrency;
+    return {
+      address: ZERO_ADDRESS,
+      symbol: nativeCurrency?.symbol ?? "NATIVE",
+      decimals: nativeCurrency?.decimals ?? 18,
+      isNative: true
+    };
+  }
+  if (!isValidAddress(quoteTokenAddress)) return void 0;
+  const [symbol, decimals] = await Promise.all([readErc20Symbol(publicClient, quoteTokenAddress), readErc20Decimals(publicClient, quoteTokenAddress)]);
+  return {
+    address: quoteTokenAddress,
+    symbol: symbol ?? "TOKEN",
+    decimals,
+    isNative: false
+  };
+}
+async function readErc20TokenMetadata(publicClient, tokenAddress) {
+  if (!tokenAddress || !isValidAddress(tokenAddress) || tokenAddress === ZERO_ADDRESS) return null;
+  const [tokenSymbol, tokenName] = await Promise.all([readErc20Symbol(publicClient, tokenAddress), readErc20Name(publicClient, tokenAddress)]);
+  if (!tokenSymbol && !tokenName) return null;
+  return {
+    tokenSymbol,
+    tokenName
+  };
+}
+async function loadTokenRuntimeSnapshot(publicClient, chainId, tokenAddress) {
+  if (!tokenAddress || !isValidAddress(tokenAddress) || tokenAddress === ZERO_ADDRESS) return null;
+  const metadata = await readErc20TokenMetadata(publicClient, tokenAddress);
+  const chainConfig = getTaxVaultHostChainConfig(chainId);
+  const baseSnapshot = {
+    tokenSymbol: metadata?.tokenSymbol,
+    tokenName: metadata?.tokenName,
+    copyScope: "tax"
+  };
+  if (!chainConfig) {
+    return {
+      ...baseSnapshot,
+      hasTaxVaults: false,
+      hostReadSupported: false,
+      hostReadFromChain: false
+    };
+  }
+  let tokenData;
+  try {
+    tokenData = await publicClient.readContract({
+      address: chainConfig.portal,
+      abi: portalAbi,
+      functionName: "getTokenV7",
+      args: [tokenAddress]
+    });
+  } catch {
+    return {
+      ...baseSnapshot,
+      hasTaxVaults: Boolean(chainConfig.vaultPortal),
+      hostReadSupported: true,
+      hostReadFromChain: false,
+      giftVaultFactory: chainConfig.giftVaultFactory
+    };
+  }
+  const tokenInfo = parsePortalTokenInfo(tokenData);
+  const hasTaxVaults = Boolean(chainConfig.vaultPortal);
+  if (!tokenInfo) {
+    return {
+      ...baseSnapshot,
+      hasTaxVaults,
+      hostReadSupported: true,
+      hostReadFromChain: false,
+      giftVaultFactory: chainConfig.giftVaultFactory
+    };
+  }
+  const paymentToken = tokenInfo.exists ? await resolvePaymentToken(publicClient, tokenInfo) : void 0;
+  if (!tokenInfo.exists) {
+    const host2 = createTaxInfoHostContext({
+      tokenInfo,
+      giftVaultFactory: chainConfig.giftVaultFactory,
+      hasTaxVaults,
+      copyScope: "tax"
+    });
+    return {
+      ...baseSnapshot,
+      tokenInfo,
+      host: host2,
+      giftVaultFactory: chainConfig.giftVaultFactory,
+      paymentToken,
+      hasTaxVaults,
+      hostReadSupported: true,
+      hostReadFromChain: true
+    };
+  }
+  const taxInfoPromise = tokenInfo.isTaxToken && chainConfig.taxTokenHelperAddress ? Promise.allSettled([
+    publicClient.readContract({
+      address: chainConfig.taxTokenHelperAddress,
+      abi: taxTokenHelperAbi,
+      functionName: "getTaxTokenInfo",
+      args: [tokenAddress]
+    }),
+    publicClient.readContract({
+      address: chainConfig.taxTokenHelperAddress,
+      abi: taxTokenHelperAbi,
+      functionName: "getTaxTokenInfoV2",
+      args: [tokenAddress]
+    })
+  ]) : Promise.resolve(null);
+  const vaultInfoPromise = chainConfig.vaultPortal ? publicClient.readContract({
+    address: chainConfig.vaultPortal,
+    abi: vaultPortalAbi,
+    functionName: "tryGetVault",
+    args: [tokenAddress]
+  }).catch(() => void 0) : Promise.resolve(void 0);
+  const [taxResults, vaultData] = await Promise.all([taxInfoPromise, vaultInfoPromise]);
+  const baseTaxInfo = Array.isArray(taxResults) && taxResults[0]?.status === "fulfilled" ? taxResults[0].value : void 0;
+  const taxInfoV2 = Array.isArray(taxResults) && taxResults[1]?.status === "fulfilled" ? taxResults[1].value : void 0;
+  const taxInfo = baseTaxInfo ? parseTaxTokenInfo(baseTaxInfo, taxInfoV2, { wrappedNativeTokenAddress: chainConfig.wrappedNativeTokenAddress }) : void 0;
+  const vaultInfo = vaultData ? parseVaultPortalInfo(vaultData) : void 0;
+  const host = createTaxInfoHostContext({
+    tokenInfo,
+    taxInfo,
+    vaultInfo,
+    giftVaultFactory: chainConfig.giftVaultFactory,
+    hasTaxVaults,
+    copyScope: "tax"
+  });
+  return {
+    ...baseSnapshot,
+    tokenInfo,
+    taxInfo,
+    vaultInfo,
+    host,
+    giftVaultFactory: chainConfig.giftVaultFactory,
+    paymentToken,
+    hasTaxVaults,
+    hostReadSupported: true,
+    hostReadFromChain: true
+  };
+}
+
+// src/sdk/hostRuntime.ts
+function isResolvedAddress(address) {
+  return Boolean(address && isValidAddress(address) && address !== ZERO_ADDRESS);
+}
+function pickAddress(...candidates) {
+  for (const candidate of candidates) {
+    if (isResolvedAddress(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolveAddresses(input, snapshot) {
+  return {
+    chainId: input.chainId,
+    tokenAddress: input.tokenAddress,
+    factoryAddressHint: input.factoryAddressHint,
+    vaultAddressHint: input.vaultAddressHint,
+    factoryAddress: pickAddress(input.factoryAddressHint, snapshot?.vaultInfo?.vaultFactory, snapshot?.taxInfo?.vaultInfo?.factory ?? void 0),
+    vaultAddress: pickAddress(input.vaultAddressHint, snapshot?.vaultInfo?.vault, snapshot?.taxInfo?.vaultInfo?.addr ?? void 0)
+  };
+}
+function hasPresentationMetadata(result) {
+  return Boolean(result.presentation?.tokenName || result.presentation?.tokenSymbol || result.presentation?.tokenImageUrl);
+}
+function resolveTokenMetadataSource(snapshot, presentationDataAvailable) {
+  if (presentationDataAvailable) return "host-proxy";
+  if (snapshot?.tokenName || snapshot?.tokenSymbol) return "onchain";
+  return "unavailable";
+}
+function resolveSources(snapshot, presentationDataAvailable) {
+  return {
+    tokenMetadata: resolveTokenMetadataSource(snapshot, presentationDataAvailable),
+    taxState: snapshot?.taxInfo ? "onchain" : "unavailable",
+    vaultState: snapshot?.vaultInfo?.found || snapshot?.taxInfo?.vaultInfo?.isVault ? "onchain" : "unavailable",
+    presentation: presentationDataAvailable ? "host-proxy" : "unavailable"
+  };
+}
+function collectWarnings(snapshot, addresses) {
+  const warnings = [];
+  if (!snapshot?.taxInfo) warnings.push("tax-info-unavailable");
+  if (snapshot?.tokenInfo?.quoteTokenAddress && !snapshot.paymentToken) warnings.push("payment-token-unavailable");
+  if (!addresses.vaultAddress) warnings.push("vault-address-unavailable");
+  if (!addresses.factoryAddress) warnings.push("factory-address-unavailable");
+  return warnings;
+}
+function resolveChainFailure(snapshot) {
+  if (!snapshot) return "chain-read-unavailable";
+  if (!snapshot.hostReadSupported) return "unsupported-chain";
+  if (!snapshot.hostReadFromChain || !snapshot.tokenInfo) return "chain-read-unavailable";
+  if (!snapshot.tokenInfo.exists) return "token-not-found";
+  if (!snapshot.tokenInfo.isTaxToken) return "token-not-tax";
+  return null;
+}
+function createResult(params) {
+  const addresses = resolveAddresses(params.input, params.snapshot);
+  const basePresentation = params.presentation ?? null;
+  const baseResult = {
+    status: params.status,
+    policy: params.policy,
+    degradeReason: params.degradeReason,
+    warnings: collectWarnings(params.snapshot, addresses),
+    addresses,
+    snapshot: params.snapshot,
+    host: params.snapshot?.host ?? void 0,
+    paymentToken: params.snapshot?.paymentToken,
+    tokenSymbol: basePresentation?.tokenSymbol ?? params.snapshot?.tokenSymbol,
+    tokenName: basePresentation?.tokenName ?? params.snapshot?.tokenName,
+    tokenImageUrl: basePresentation?.tokenImageUrl,
+    tokenDetailHref: basePresentation?.tokenDetailHref,
+    chainHref: basePresentation?.chainHref,
+    presentation: basePresentation,
+    sources: {
+      tokenMetadata: "unavailable",
+      taxState: "unavailable",
+      vaultState: "unavailable",
+      presentation: "unavailable"
+    }
+  };
+  baseResult.sources = resolveSources(params.snapshot, hasPresentationMetadata(baseResult));
+  return baseResult;
+}
+function resolveHostRuntimeAddresses(input, snapshot) {
+  return resolveAddresses(input, snapshot);
+}
+async function runHostRuntime(input) {
+  const policy = input.policy ?? "prefer-full-host";
+  if (!isResolvedAddress(input.tokenAddress)) {
+    return createResult({
+      status: "unavailable",
+      input,
+      snapshot: null,
+      degradeReason: "invalid-token-address",
+      policy
+    });
+  }
+  const snapshot = await loadTokenRuntimeSnapshot(input.publicClient, input.chainId, input.tokenAddress);
+  const chainFailure = resolveChainFailure(snapshot);
+  if (chainFailure) {
+    return createResult({
+      status: "unavailable",
+      input,
+      snapshot,
+      degradeReason: chainFailure,
+      policy
+    });
+  }
+  let presentation = null;
+  let presentationFailure;
+  if (input.presentationFetcher) {
+    try {
+      presentation = await input.presentationFetcher({
+        chainId: input.chainId,
+        tokenAddress: input.tokenAddress,
+        factoryAddress: resolveAddresses(input, snapshot).factoryAddress,
+        vaultAddress: resolveAddresses(input, snapshot).vaultAddress,
+        snapshot
+      });
+      if (!presentation) {
+        presentationFailure = "host-presentation-unavailable";
+      }
+    } catch {
+      presentationFailure = "host-presentation-unavailable";
+    }
+  } else {
+    presentationFailure = "host-presentation-not-configured";
+  }
+  if (presentation) {
+    return createResult({
+      status: "full-host",
+      input,
+      snapshot,
+      presentation,
+      policy
+    });
+  }
+  if (policy === "require-full-host") {
+    return createResult({
+      status: "unavailable",
+      input,
+      snapshot,
+      degradeReason: presentationFailure === "host-presentation-not-configured" ? "host-presentation-required" : "host-presentation-unavailable",
+      policy
+    });
+  }
+  const result = createResult({
+    status: "onchain",
+    input,
+    snapshot,
+    degradeReason: presentationFailure,
+    policy
+  });
+  const hostSnapshot = readTaxVaultHostContext(result.host);
+  if (!hostSnapshot.isSupportedCustomVaultToken) {
+    return {
+      ...result,
+      status: "unavailable",
+      degradeReason: "token-not-tax"
+    };
+  }
+  return result;
+}
+
+// src/sdk/runtimeContext.ts
+var zeroAddress = "0x0000000000000000000000000000000000000000";
+function explorerForChain(chainId) {
+  if (chainId === 56) return "https://bscscan.com";
+  if (chainId === 97) return "https://testnet.bscscan.com";
+  return void 0;
+}
+function chainLabelForChain(chainId) {
+  if (chainId === 56) return "BNB Chain";
+  if (chainId === 97) return "BNB Testnet";
+  return `Chain ${chainId}`;
+}
+function buildRuntimeExtraConfig(input) {
+  const hostRuntimeResult = input.hostRuntimeResult;
+  const runtimeOverrides = input.runtimeOverrides;
+  return {
+    ...hostRuntimeResult ? {
+      hostRuntimeStatus: hostRuntimeResult.status,
+      hostRuntimePolicy: hostRuntimeResult.policy,
+      hostRuntimeDegradeReason: hostRuntimeResult.degradeReason,
+      hostRuntimeWarnings: hostRuntimeResult.warnings
+    } : {},
+    ...hostRuntimeResult?.presentation?.extraConfig ?? {},
+    ...runtimeOverrides?.extraConfig ?? {}
+  };
+}
+function createVaultRuntimeContext(input) {
+  const runtimeOverrides = input.runtimeOverrides;
+  const resolvedBinding = resolveManifestBinding(input.manifest, {
+    chainId: runtimeOverrides?.chainId ?? input.connectedChainId ?? input.hostRuntimeResult?.addresses.chainId,
+    factoryAddress: runtimeOverrides?.factoryAddress ?? input.hostRuntimeResult?.addresses.factoryAddress
+  });
+  const effectiveChainId = runtimeOverrides?.chainId ?? input.hostRuntimeResult?.addresses.chainId ?? input.connectedChainId ?? resolvedBinding?.chainId ?? input.manifest.match.bindings[0]?.chainId ?? 56;
+  return {
+    chainId: effectiveChainId,
+    factoryAddress: runtimeOverrides?.factoryAddress ?? input.hostRuntimeResult?.addresses.factoryAddress ?? resolvedBinding?.factoryAddress ?? zeroAddress,
+    tokenAddress: runtimeOverrides?.tokenAddress ?? input.hostRuntimeResult?.addresses.tokenAddress ?? zeroAddress,
+    vaultAddress: runtimeOverrides?.vaultAddress ?? input.hostRuntimeResult?.addresses.vaultAddress ?? zeroAddress,
+    userAddress: runtimeOverrides?.userAddress,
+    tokenSymbol: runtimeOverrides?.tokenSymbol ?? input.hostRuntimeResult?.tokenSymbol,
+    tokenName: runtimeOverrides?.tokenName ?? input.hostRuntimeResult?.tokenName,
+    tokenImageUrl: runtimeOverrides?.tokenImageUrl ?? input.hostRuntimeResult?.tokenImageUrl,
+    explorerBaseUrl: runtimeOverrides?.explorerBaseUrl ?? explorerForChain(effectiveChainId),
+    paymentToken: runtimeOverrides?.paymentToken ?? input.hostRuntimeResult?.paymentToken,
+    host: runtimeOverrides?.host ?? input.hostRuntimeResult?.host,
+    extraConfig: buildRuntimeExtraConfig(input),
+    manifest: input.manifest
+  };
+}
+
+// src/sdk/txError.ts
+var defaultMessages = {
+  userRejected: "You rejected the wallet request.",
+  walletDisconnected: "Connect a wallet before sending this transaction.",
+  wrongNetwork: "Switch the wallet to the required chain before sending this transaction.",
+  insufficientFunds: "Insufficient wallet balance to complete this transaction.",
+  simulationFailed: "The transaction could not pass simulation.",
+  reverted: "The contract rejected this transaction.",
+  unknown: "Transaction failed. Please check your wallet and try again."
+};
+function isObject(value) {
+  return Boolean(value) && typeof value === "object";
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function collectMessages(error, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (depth > 4 || error == null || seen.has(error)) return [];
+  seen.add(error);
+  if (typeof error === "string") return [error];
+  if (!isObject(error)) return [];
+  const messages = [
+    readString(error.shortMessage),
+    readString(error.message),
+    readString(error.details),
+    readString(error.reason)
+  ].filter(Boolean);
+  return [...messages, ...collectMessages(error.cause, depth + 1, seen)];
+}
+function collectCodes(error, depth = 0, seen = /* @__PURE__ */ new Set()) {
+  if (depth > 4 || error == null || seen.has(error)) return [];
+  seen.add(error);
+  if (!isObject(error)) return [];
+  const codes = [error.code, error.name].filter((value) => typeof value === "string" || typeof value === "number");
+  return [...codes, ...collectCodes(error.cause, depth + 1, seen)];
+}
+function getTxErrorKind(error) {
+  const message = collectMessages(error).join(" ").toLowerCase();
+  const codes = collectCodes(error).map((value) => String(value).toLowerCase()).join(" ");
+  if (codes.includes("4001") || codes.includes("action_rejected") || codes.includes("userrejectedrequesterror") || /user rejected|user denied|rejected the request|denied transaction|request rejected|cancelled/i.test(message)) {
+    return "userRejected";
+  }
+  if (/wallet is not connected|connector not connected|account not found|no wallet client/i.test(message)) {
+    return "walletDisconnected";
+  }
+  if (/wrong network|switch wallet to|switch network to|required chain/i.test(message)) {
+    return "wrongNetwork";
+  }
+  if (/insufficient funds|exceeds the balance|gas \* price \+ value/i.test(message)) {
+    return "insufficientFunds";
+  }
+  if (/simulation failed|simulatecontract|execution reverted during simulation/i.test(message)) {
+    return "simulationFailed";
+  }
+  if (/execution reverted|reverted with the following reason|contract function .* reverted|call exception/i.test(message)) {
+    return "reverted";
+  }
+  return "unknown";
+}
+function handleTxError(error, messages) {
+  const kind = getTxErrorKind(error);
+  return messages?.[kind] ?? defaultMessages[kind];
+}
+
+export { ZERO_ADDRESS, chainLabelForChain, createTaxInfoHostContext, createVaultRuntimeContext, explorerForChain, formatCountdown, formatPercentBps, formatTokenAmount, getTaxVaultHostChainConfig, getTupleField, getTxErrorKind, handleTxError, isActionAvailableForPhase, isCustomVaultTaxToken, isManifestRuntimeMatch, isSameAddress, isValidAddress, isVaultBindingMatch, loadTokenRuntimeSnapshot, normalizeAddress, parseFeeVaultInfo, parsePortalTokenInfo, parseTaxTokenInfo, parseTokenAmount, parseVaultPortalInfo, readErc20TokenMetadata, readTaxVaultHostContext, resolveFeeMode, resolveHostRuntimeAddresses, resolveManifestBinding, resolveTaxInfoRenderSurface, resolveTokenMarketPhase, resolveVaultBinding, runHostRuntime, shortenAddress, standardErc20Abi };
+//# sourceMappingURL=host.js.map
+//# sourceMappingURL=host.js.map