@elisym/sdk 0.7.0 → 0.9.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var system = require('@solana-program/system');
+var token = require('@solana-program/token');
 var kit = require('@solana/kit');
 var Decimal2 = require('decimal.js-light');
 var zod = require('zod');
@@ -118,13 +119,13 @@ function decodeConfig(encodedAccount) {
     getConfigDecoder()
   );
 }
-async function fetchConfig(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeConfig(rpc, address2, config);
+async function fetchConfig(rpc, address3, config) {
+  const maybeAccount = await fetchMaybeConfig(rpc, address3, config);
   kit.assertAccountExists(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeConfig(rpc, address2, config) {
-  const maybeAccount = await kit.fetchEncodedAccount(rpc, address2, config);
+async function fetchMaybeConfig(rpc, address3, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address3, config);
   return decodeConfig(maybeAccount);
 }
 if (process.env.NODE_ENV !== "production") ;
@@ -175,6 +176,99 @@ async function getProtocolConfig(rpc, programId, options) {
     );
   }
 }
+
+// src/payment/assets.ts
+var NATIVE_SOL = {
+  chain: "solana",
+  token: "sol",
+  decimals: 9,
+  symbol: "SOL"
+};
+var USDC_SOLANA_DEVNET = {
+  chain: "solana",
+  token: "usdc",
+  mint: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+  decimals: 6,
+  symbol: "USDC"
+};
+var KNOWN_ASSETS = [NATIVE_SOL, USDC_SOLANA_DEVNET];
+function assetKey(a) {
+  return a.mint ? `${a.chain}:${a.token}:${a.mint}` : `${a.chain}:${a.token}`;
+}
+function resolveKnownAsset(chain, token, mint) {
+  const key = mint ? `${chain}:${token}:${mint}` : `${chain}:${token}`;
+  return KNOWN_ASSETS.find((asset) => assetKey(asset) === key);
+}
+function assetByKey(key) {
+  return KNOWN_ASSETS.find((asset) => assetKey(asset) === key);
+}
+function resolveAssetFromPaymentRequest(request) {
+  if (!request.asset) {
+    return NATIVE_SOL;
+  }
+  const found = resolveKnownAsset(request.asset.chain, request.asset.token, request.asset.mint);
+  if (!found) {
+    const display = request.asset.mint ? `${request.asset.chain}:${request.asset.token}:${request.asset.mint}` : `${request.asset.chain}:${request.asset.token}`;
+    throw new Error(
+      `Unknown asset in payment request: ${display}. Known assets: ${KNOWN_ASSETS.map(assetKey).join(", ")}`
+    );
+  }
+  return found;
+}
+var DECIMAL_RE = /^(\d+\.\d*|\d*\.\d+|\d+)$/;
+function parseAssetAmount(asset, human) {
+  const trimmed = human.trim();
+  if (!trimmed) {
+    throw new Error(`${asset.symbol} amount is empty`);
+  }
+  if (trimmed.startsWith("-")) {
+    throw new Error(`${asset.symbol} amount cannot be negative`);
+  }
+  if (!DECIMAL_RE.test(trimmed)) {
+    throw new Error(
+      `${asset.symbol} amount must be a non-negative decimal (e.g. "0.5", "1"); got "${human}"`
+    );
+  }
+  const dotPos = trimmed.indexOf(".");
+  let wholePart;
+  if (dotPos === -1) {
+    wholePart = trimmed;
+  } else if (dotPos === 0) {
+    wholePart = "0";
+  } else {
+    wholePart = trimmed.slice(0, dotPos);
+  }
+  const fracPart = dotPos === -1 ? "" : trimmed.slice(dotPos + 1);
+  if (fracPart.length > asset.decimals) {
+    throw new Error(
+      `${asset.symbol} amount has too many decimals (max ${asset.decimals}); got "${human}"`
+    );
+  }
+  const unit = 10n ** BigInt(asset.decimals);
+  const whole = BigInt(wholePart);
+  const frac = fracPart ? BigInt(fracPart.padEnd(asset.decimals, "0")) : 0n;
+  const raw = whole * unit + frac;
+  if (raw === 0n) {
+    throw new Error(`${asset.symbol} amount must be positive; got "${human}"`);
+  }
+  if (raw > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(
+      `${asset.symbol} amount exceeds safe range (max ${Number.MAX_SAFE_INTEGER} subunits)`
+    );
+  }
+  return raw;
+}
+function formatAssetAmount(asset, raw) {
+  const sign = raw < 0n ? "-" : "";
+  const abs = raw < 0n ? -raw : raw;
+  const unit = 10n ** BigInt(asset.decimals);
+  const whole = abs / unit;
+  const frac = abs % unit;
+  if (asset.decimals === 0) {
+    return `${sign}${whole} ${asset.symbol}`;
+  }
+  return `${sign}${whole}.${frac.toString().padStart(asset.decimals, "0")} ${asset.symbol}`;
+}
 var BPS_DENOMINATOR = 1e4;
 function assertLamports(value, field) {
   if (!Number.isInteger(value) || value < 0) {
@@ -284,6 +378,12 @@ var SOLANA_ADDRESS_LENGTH_RE = /^.{32,44}$/;
 var lamportsSchema = zod.z.number().int().positive().max(MAX_SAFE_LAMPORTS, `amount must be <= ${MAX_SAFE_LAMPORTS}`);
 var feeAmountSchema = zod.z.number().int().nonnegative().max(MAX_SAFE_LAMPORTS, `fee_amount must be <= ${MAX_SAFE_LAMPORTS}`);
 var solanaAddressSchema = zod.z.string().regex(BASE58_RE, "must be base58").regex(SOLANA_ADDRESS_LENGTH_RE, "must be 32-44 base58 chars");
+var paymentAssetRefSchema = zod.z.object({
+  chain: zod.z.string().min(1),
+  token: zod.z.string().min(1),
+  mint: solanaAddressSchema.optional(),
+  decimals: zod.z.number().int().min(0).max(18)
+});
 var PaymentRequestSchema = zod.z.object({
   recipient: solanaAddressSchema,
   amount: lamportsSchema,
@@ -292,7 +392,8 @@ var PaymentRequestSchema = zod.z.object({
   fee_address: solanaAddressSchema.optional(),
   fee_amount: feeAmountSchema.optional(),
   created_at: zod.z.number().int().positive(),
-  expiry_secs: zod.z.number().int().positive().max(MAX_EXPIRY_SECS_SCHEMA, `expiry_secs must be <= ${MAX_EXPIRY_SECS_SCHEMA}`)
+  expiry_secs: zod.z.number().int().positive().max(MAX_EXPIRY_SECS_SCHEMA, `expiry_secs must be <= ${MAX_EXPIRY_SECS_SCHEMA}`),
+  asset: paymentAssetRefSchema.optional()
 });
 function parsePaymentRequest(input, options) {
   let parsed;
@@ -374,6 +475,12 @@ var SolanaPaymentStrategy = class {
     assertExpirySecs(expirySecs);
     const feeAmount = calculateProtocolFee(amount, config.feeBps);
     const reference = generateReference();
+    const assetRef = options?.asset && options.asset !== NATIVE_SOL ? {
+      chain: options.asset.chain,
+      token: options.asset.token,
+      mint: options.asset.mint,
+      decimals: options.asset.decimals
+    } : void 0;
     return {
       recipient: recipientAddress,
       amount,
@@ -381,7 +488,8 @@ var SolanaPaymentStrategy = class {
       fee_address: config.treasury,
       fee_amount: feeAmount,
       created_at: Math.floor(Date.now() / 1e3),
-      expiry_secs: expirySecs
+      expiry_secs: expirySecs,
+      ...assetRef ? { asset: assetRef } : {}
     };
   }
   validatePaymentRequest(requestJson, config, expectedRecipient, options) {
@@ -399,6 +507,16 @@ var SolanaPaymentStrategy = class {
       return { code: "invalid_amount", message: parsed.error.message };
     }
     const data = parsed.data;
+    if (data.asset) {
+      try {
+        resolveAssetFromPaymentRequest(data);
+      } catch (error) {
+        return {
+          code: "invalid_asset",
+          message: error instanceof Error ? error.message : String(error)
+        };
+      }
+    }
     if (!isValidSolanaAddress(data.recipient)) {
       return {
         code: "invalid_recipient_address",
@@ -487,7 +605,7 @@ var SolanaPaymentStrategy = class {
     if (!Number.isInteger(computeUnitLimit) || computeUnitLimit <= 0) {
       throw new Error(`Invalid computeUnitLimit: ${computeUnitLimit}. Must be a positive integer.`);
     }
-    const paymentInstructions = buildPaymentInstructions(paymentRequest, payerSigner);
+    const paymentInstructions = await buildPaymentInstructions(paymentRequest, payerSigner);
     const priorityFeeMicroLamports = options?.priorityFeeMicroLamports ?? await estimatePriorityFeeMicroLamports(rpc, {
       percentile: options?.priorityFeePercentile ?? DEFAULT_PRIORITY_FEE_PERCENTILE
     });
@@ -549,6 +667,16 @@ var SolanaPaymentStrategy = class {
         error: `Fee amount (${feeAmount}) exceeds or equals total amount (${paymentRequest.amount})`
       };
     }
+    let asset;
+    try {
+      asset = resolveAssetFromPaymentRequest(paymentRequest);
+    } catch (error) {
+      return {
+        verified: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const mint = asset.mint;
     if (options?.txSignature) {
       return this._verifyBySignature(
         rpc,
@@ -558,6 +686,7 @@ var SolanaPaymentStrategy = class {
         treasury,
         expectedNet,
         feeAmount,
+        mint,
         options?.retries ?? DEFAULTS.VERIFY_RETRIES,
         options?.intervalMs ?? DEFAULTS.VERIFY_INTERVAL_MS
       );
@@ -569,11 +698,12 @@ var SolanaPaymentStrategy = class {
       treasury,
       expectedNet,
       feeAmount,
+      mint,
       options?.retries ?? DEFAULTS.VERIFY_BY_REF_RETRIES,
       options?.intervalMs ?? DEFAULTS.VERIFY_BY_REF_INTERVAL_MS
     );
   }
-  async _verifyBySignature(rpc, txSignature, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, retries, intervalMs) {
+  async _verifyBySignature(rpc, txSignature, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, mint, retries, intervalMs) {
     let lastError;
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
@@ -592,15 +722,18 @@ var SolanaPaymentStrategy = class {
             error: tx?.meta?.err ? "Transaction failed on-chain" : "Transaction not found"
           };
         }
-        const verdict = checkBalanceDiff({
+        const verdict = checkTxDiff({
           accountKeys: tx.transaction.message.accountKeys,
           preBalances: tx.meta.preBalances,
           postBalances: tx.meta.postBalances,
+          preTokenBalances: tx.meta.preTokenBalances,
+          postTokenBalances: tx.meta.postTokenBalances,
           referenceKey,
           recipientAddress,
           treasuryAddress,
           expectedNet,
-          expectedFee
+          expectedFee,
+          mint
         });
         if (verdict.ok) {
           return { verified: true, txSignature };
@@ -618,7 +751,7 @@ var SolanaPaymentStrategy = class {
       error: `Verification failed after ${retries} retries: ${lastError instanceof Error ? lastError.message : "unknown error"}`
     };
   }
-  async _verifyByReference(rpc, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, retries, intervalMs) {
+  async _verifyByReference(rpc, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, mint, retries, intervalMs) {
     let lastError;
     const reference = kit.address(referenceKey);
     for (let attempt = 0; attempt < retries; attempt++) {
@@ -642,15 +775,18 @@ var SolanaPaymentStrategy = class {
             if (!tx?.meta || tx.meta.err) {
               continue;
             }
-            const verdict = checkBalanceDiff({
+            const verdict = checkTxDiff({
               accountKeys: tx.transaction.message.accountKeys,
               preBalances: tx.meta.preBalances,
               postBalances: tx.meta.postBalances,
+              preTokenBalances: tx.meta.preTokenBalances,
+              postTokenBalances: tx.meta.postTokenBalances,
               referenceKey,
               recipientAddress,
               treasuryAddress,
               expectedNet,
-              expectedFee
+              expectedFee,
+              mint
             });
             if (verdict.ok) {
               return { verified: true, txSignature: sig };
@@ -670,7 +806,7 @@ var SolanaPaymentStrategy = class {
     };
   }
 };
-function checkBalanceDiff(input) {
+function checkTxDiff(input) {
   const balanceCount = input.preBalances.length;
   const keyToIdx = /* @__PURE__ */ new Map();
   for (let i = 0; i < Math.min(input.accountKeys.length, balanceCount); i++) {
@@ -682,6 +818,9 @@ function checkBalanceDiff(input) {
   if (!keyToIdx.has(input.referenceKey)) {
     return { ok: false, reason: "Reference key not found in transaction - possible replay" };
   }
+  if (input.mint) {
+    return checkTokenBalanceDiff(input);
+  }
   const recipientIdx = keyToIdx.get(input.recipientAddress);
   if (recipientIdx === void 0) {
     return { ok: false, reason: "Recipient not found in transaction" };
@@ -714,6 +853,47 @@ function checkBalanceDiff(input) {
   }
   return { ok: true };
 }
+function checkTokenBalanceDiff(input) {
+  const mint = input.mint;
+  if (!mint) {
+    return { ok: false, reason: "Expected mint for SPL verification, got none" };
+  }
+  const pre = input.preTokenBalances ?? [];
+  const post = input.postTokenBalances ?? [];
+  const tokenDelta = (ownerAddress) => {
+    const preEntry = pre.find((entry) => entry.owner === ownerAddress && entry.mint === mint);
+    const postEntry = post.find((entry) => entry.owner === ownerAddress && entry.mint === mint);
+    if (!postEntry) {
+      return -1n;
+    }
+    const preAmount = preEntry ? BigInt(preEntry.uiTokenAmount.amount) : 0n;
+    const postAmount = BigInt(postEntry.uiTokenAmount.amount);
+    return postAmount - preAmount;
+  };
+  const recipientDelta = tokenDelta(input.recipientAddress);
+  if (recipientDelta === -1n) {
+    return { ok: false, reason: "Recipient token account not found in transaction" };
+  }
+  if (recipientDelta < BigInt(input.expectedNet)) {
+    return {
+      ok: false,
+      reason: `Recipient received ${recipientDelta.toString()} tokens, expected >= ${input.expectedNet}`
+    };
+  }
+  if (input.expectedFee > 0) {
+    const treasuryDelta = tokenDelta(input.treasuryAddress);
+    if (treasuryDelta === -1n) {
+      return { ok: false, reason: "Treasury token account not found in transaction" };
+    }
+    if (treasuryDelta < BigInt(input.expectedFee)) {
+      return {
+        ok: false,
+        reason: `Treasury received ${treasuryDelta.toString()} tokens, expected >= ${input.expectedFee}`
+      };
+    }
+  }
+  return { ok: true };
+}
 function bigIntDelta(post, pre) {
   const postValue = post === void 0 ? 0n : BigInt(post);
   const preValue = pre === void 0 ? 0n : BigInt(pre);
@@ -722,7 +902,7 @@ function bigIntDelta(post, pre) {
 function waitMs(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function buildPaymentInstructions(paymentRequest, payerSigner) {
+async function buildPaymentInstructions(paymentRequest, payerSigner) {
   const recipient = kit.address(paymentRequest.recipient);
   const reference = kit.address(paymentRequest.reference);
   const feeAmount = paymentRequest.fee_amount ?? 0;
@@ -732,22 +912,98 @@ function buildPaymentInstructions(paymentRequest, payerSigner) {
       `Fee amount (${feeAmount}) exceeds or equals total amount (${paymentRequest.amount}). Cannot create transaction with non-positive provider amount.`
     );
   }
-  const providerTransferIx = system.getTransferSolInstruction({
-    source: payerSigner,
-    destination: recipient,
-    amount: BigInt(providerAmount)
+  const asset = resolveAssetFromPaymentRequest(paymentRequest);
+  if (!asset.mint) {
+    const providerTransferIx2 = system.getTransferSolInstruction({
+      source: payerSigner,
+      destination: recipient,
+      amount: BigInt(providerAmount)
+    });
+    const providerTransferIxWithReference2 = {
+      ...providerTransferIx2,
+      accounts: [
+        ...providerTransferIx2.accounts,
+        { address: reference, role: kit.AccountRole.READONLY }
+      ]
+    };
+    const instructions2 = [providerTransferIxWithReference2];
+    if (paymentRequest.fee_address && feeAmount > 0) {
+      instructions2.push(
+        system.getTransferSolInstruction({
+          source: payerSigner,
+          destination: kit.address(paymentRequest.fee_address),
+          amount: BigInt(feeAmount)
+        })
+      );
+    }
+    return instructions2;
+  }
+  const mint = kit.address(asset.mint);
+  const payerAddress = payerSigner.address;
+  const [payerAta] = await token.findAssociatedTokenPda({
+    owner: payerAddress,
+    tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+    mint
+  });
+  const [recipientAta] = await token.findAssociatedTokenPda({
+    owner: recipient,
+    tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+    mint
+  });
+  const instructions = [];
+  instructions.push(
+    token.getCreateAssociatedTokenIdempotentInstruction(
+      {
+        payer: payerSigner,
+        ata: recipientAta,
+        owner: recipient,
+        mint
+      },
+      { programAddress: token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS }
+    )
+  );
+  let treasuryAta;
+  if (paymentRequest.fee_address && feeAmount > 0) {
+    const treasuryOwner = kit.address(paymentRequest.fee_address);
+    [treasuryAta] = await token.findAssociatedTokenPda({
+      owner: treasuryOwner,
+      tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+      mint
+    });
+    instructions.push(
+      token.getCreateAssociatedTokenIdempotentInstruction(
+        {
+          payer: payerSigner,
+          ata: treasuryAta,
+          owner: treasuryOwner,
+          mint
+        },
+        { programAddress: token.ASSOCIATED_TOKEN_PROGRAM_ADDRESS }
+      )
+    );
+  }
+  const providerTransferIx = token.getTransferCheckedInstruction({
+    source: payerAta,
+    mint,
+    destination: recipientAta,
+    authority: payerSigner,
+    amount: BigInt(providerAmount),
+    decimals: asset.decimals
   });
   const providerTransferIxWithReference = {
     ...providerTransferIx,
     accounts: [...providerTransferIx.accounts, { address: reference, role: kit.AccountRole.READONLY }]
   };
-  const instructions = [providerTransferIxWithReference];
-  if (paymentRequest.fee_address && feeAmount > 0) {
+  instructions.push(providerTransferIxWithReference);
+  if (treasuryAta && paymentRequest.fee_address && feeAmount > 0) {
     instructions.push(
-      system.getTransferSolInstruction({
-        source: payerSigner,
-        destination: kit.address(paymentRequest.fee_address),
-        amount: BigInt(feeAmount)
+      token.getTransferCheckedInstruction({
+        source: payerAta,
+        mint,
+        destination: treasuryAta,
+        authority: payerSigner,
+        amount: BigInt(feeAmount),
+        decimals: asset.decimals
       })
     );
   }
@@ -2356,6 +2612,133 @@ var ElisymClient = class {
     this.pool.close();
   }
 };
+var DEFAULT_COMPUTE_UNIT_LIMIT2 = 2e5;
+var DEFAULT_PRIORITY_FEE_PERCENTILE2 = 75;
+var BASE_FEE_LAMPORTS_PER_SIGNATURE = 5000n;
+var FALLBACK_ATA_RENT_LAMPORTS = 2039280n;
+var SPL_TOKEN_ACCOUNT_SIZE = 165;
+async function estimateSolFeeLamports(rpc, paymentRequest, _payerAddress, options) {
+  const numSignatures = options?.numSignatures ?? 1;
+  const computeUnitLimit = options?.computeUnitLimit ?? DEFAULT_COMPUTE_UNIT_LIMIT2;
+  const priorityFeeMicroLamports = options?.priorityFeeMicroLamports ?? await estimatePriorityFeeMicroLamports(rpc, {
+    percentile: options?.priorityFeePercentile ?? DEFAULT_PRIORITY_FEE_PERCENTILE2
+  });
+  const baseFeeLamports = BASE_FEE_LAMPORTS_PER_SIGNATURE * BigInt(numSignatures);
+  const priorityFeeLamports = ceilDiv(
+    priorityFeeMicroLamports * BigInt(computeUnitLimit),
+    1000000n
+  );
+  const asset = resolveAssetFromPaymentRequest(paymentRequest);
+  let rentLamports = 0n;
+  let rentPerAtaLamports = 0n;
+  let missingAtaCount = 0;
+  if (asset.mint) {
+    rentPerAtaLamports = await fetchAtaRent(rpc);
+    const mint = kit.address(asset.mint);
+    const ataAccountsToCheck = [];
+    const [recipientAta] = await token.findAssociatedTokenPda({
+      owner: kit.address(paymentRequest.recipient),
+      tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+      mint
+    });
+    ataAccountsToCheck.push(recipientAta);
+    const feeAmount = paymentRequest.fee_amount ?? 0;
+    if (paymentRequest.fee_address && feeAmount > 0) {
+      const [treasuryAta] = await token.findAssociatedTokenPda({
+        owner: kit.address(paymentRequest.fee_address),
+        tokenProgram: token.TOKEN_PROGRAM_ADDRESS,
+        mint
+      });
+      ataAccountsToCheck.push(treasuryAta);
+    }
+    missingAtaCount = await countMissingAccounts(rpc, ataAccountsToCheck);
+    rentLamports = rentPerAtaLamports * BigInt(missingAtaCount);
+  }
+  const totalLamports = baseFeeLamports + priorityFeeLamports + rentLamports;
+  return {
+    baseFeeLamports,
+    priorityFeeLamports,
+    rentLamports,
+    totalLamports,
+    breakdown: {
+      numSignatures,
+      priorityFeeMicroLamports,
+      computeUnitLimit,
+      rentPerAtaLamports,
+      missingAtaCount
+    }
+  };
+}
+async function fetchAtaRent(rpc) {
+  try {
+    const lamports = await rpc.getMinimumBalanceForRentExemption(BigInt(SPL_TOKEN_ACCOUNT_SIZE)).send();
+    if (typeof lamports === "bigint") {
+      return lamports;
+    }
+    if (typeof lamports === "number" && Number.isFinite(lamports) && lamports > 0) {
+      return BigInt(lamports);
+    }
+    return FALLBACK_ATA_RENT_LAMPORTS;
+  } catch {
+    return FALLBACK_ATA_RENT_LAMPORTS;
+  }
+}
+async function countMissingAccounts(rpc, accounts) {
+  if (accounts.length === 0) {
+    return 0;
+  }
+  let missing = 0;
+  for (const acct of accounts) {
+    try {
+      const res = await rpc.getAccountInfo(acct, { encoding: "base64" }).send();
+      if (!res || !res.value) {
+        missing++;
+      }
+    } catch {
+      missing++;
+    }
+  }
+  return missing;
+}
+function ceilDiv(num, denom) {
+  if (denom === 0n) {
+    throw new Error("division by zero in ceilDiv");
+  }
+  const q = num / denom;
+  const r = num % denom;
+  return r === 0n ? q : q + 1n;
+}
+function formatFeeBreakdown(estimate) {
+  const line = (label, lamports) => {
+    const label16 = label.padEnd(14);
+    return `  ${label16}${lamports.toString()} lamports (${lamportsToSol(lamports)} SOL)`;
+  };
+  const lines = [
+    "Estimated SOL cost for this transaction:",
+    line("Base fee:", estimate.baseFeeLamports),
+    line("Priority fee:", estimate.priorityFeeLamports)
+  ];
+  if (estimate.rentLamports > 0n) {
+    lines.push(line("ATA rent:", estimate.rentLamports));
+  }
+  lines.push(line("Total:", estimate.totalLamports));
+  return lines.join("\n");
+}
+function lamportsToSol(lamports) {
+  const LAMPORTS_PER_SOL2 = 1000000000n;
+  const whole = lamports / LAMPORTS_PER_SOL2;
+  const frac = lamports % LAMPORTS_PER_SOL2;
+  return `${whole}.${frac.toString().padStart(9, "0")}`;
+}
+var SessionSpendLimitEntrySchema = zod.z.object({
+  chain: zod.z.enum(["solana"]),
+  token: zod.z.string().min(1).max(16).regex(/^[a-z0-9]+$/, "token must be lowercase alphanumeric"),
+  mint: zod.z.string().min(1).max(64).optional(),
+  amount: zod.z.number().positive().finite()
+}).strict();
+var GlobalConfigSchema = zod.z.object({
+  session_spend_limits: zod.z.array(SessionSpendLimitEntrySchema).max(16).optional()
+}).strict();
 function formatSol(lamports) {
   const sol = new Decimal2__default.default(lamports).div(LAMPORTS_PER_SOL);
   if (sol.gte(1e6)) {
@@ -2554,6 +2937,7 @@ exports.DEFAULT_REDACT_PATHS = DEFAULT_REDACT_PATHS;
 exports.DiscoveryService = DiscoveryService;
 exports.ElisymClient = ElisymClient;
 exports.ElisymIdentity = ElisymIdentity;
+exports.GlobalConfigSchema = GlobalConfigSchema;
 exports.INPUT_REDACT_PATHS = INPUT_REDACT_PATHS;
 exports.KIND_APP_HANDLER = KIND_APP_HANDLER;
 exports.KIND_JOB_FEEDBACK = KIND_JOB_FEEDBACK;
@@ -2563,10 +2947,12 @@ exports.KIND_JOB_RESULT = KIND_JOB_RESULT;
 exports.KIND_JOB_RESULT_BASE = KIND_JOB_RESULT_BASE;
 exports.KIND_PING = KIND_PING;
 exports.KIND_PONG = KIND_PONG;
+exports.KNOWN_ASSETS = KNOWN_ASSETS;
 exports.LAMPORTS_PER_SOL = LAMPORTS_PER_SOL;
 exports.LIMITS = LIMITS;
 exports.MarketplaceService = MarketplaceService;
 exports.MediaService = MediaService;
+exports.NATIVE_SOL = NATIVE_SOL;
 exports.NostrPool = NostrPool;
 exports.PROTOCOL_FEE_BPS = PROTOCOL_FEE_BPS;
 exports.PROTOCOL_PROGRAM_ID_DEVNET = PROTOCOL_PROGRAM_ID_DEVNET;
@@ -2575,9 +2961,13 @@ exports.PaymentRequestSchema = PaymentRequestSchema;
 exports.PingService = PingService;
 exports.RELAYS = RELAYS;
 exports.SECRET_REDACT_PATHS = SECRET_REDACT_PATHS;
+exports.SessionSpendLimitEntrySchema = SessionSpendLimitEntrySchema;
 exports.SolanaPaymentStrategy = SolanaPaymentStrategy;
+exports.USDC_SOLANA_DEVNET = USDC_SOLANA_DEVNET;
 exports.assertExpiry = assertExpiry;
 exports.assertLamports = assertLamports;
+exports.assetByKey = assetByKey;
+exports.assetKey = assetKey;
 exports.buildPaymentInstructions = buildPaymentInstructions;
 exports.calculateProtocolFee = calculateProtocolFee;
 exports.clearPriorityFeeCache = clearPriorityFeeCache;
@@ -2585,6 +2975,9 @@ exports.clearProtocolConfigCache = clearProtocolConfigCache;
 exports.createPaymentRequestWithOnchainConfig = createPaymentRequestWithOnchainConfig;
 exports.createSlidingWindowLimiter = createSlidingWindowLimiter;
 exports.estimatePriorityFeeMicroLamports = estimatePriorityFeeMicroLamports;
+exports.estimateSolFeeLamports = estimateSolFeeLamports;
+exports.formatAssetAmount = formatAssetAmount;
+exports.formatFeeBreakdown = formatFeeBreakdown;
 exports.formatSol = formatSol;
 exports.getProtocolConfig = getProtocolConfig;
 exports.getProtocolProgramId = getProtocolProgramId;
@@ -2593,8 +2986,11 @@ exports.jobResultKind = jobResultKind;
 exports.makeCensor = makeCensor;
 exports.nip44Decrypt = nip44Decrypt;
 exports.nip44Encrypt = nip44Encrypt;
+exports.parseAssetAmount = parseAssetAmount;
 exports.parsePaymentRequest = parsePaymentRequest;
 exports.pickPercentileFee = pickPercentileFee;
+exports.resolveAssetFromPaymentRequest = resolveAssetFromPaymentRequest;
+exports.resolveKnownAsset = resolveKnownAsset;
 exports.timeAgo = timeAgo;
 exports.toDTag = toDTag;
 exports.truncateKey = truncateKey;