@elisym/sdk 0.7.0 → 0.9.0

package/dist/index.js

@@ -1,4 +1,5 @@
 import { getTransferSolInstruction } from '@solana-program/system';
+import { findAssociatedTokenPda, TOKEN_PROGRAM_ADDRESS, getCreateAssociatedTokenIdempotentInstruction, ASSOCIATED_TOKEN_PROGRAM_ADDRESS, getTransferCheckedInstruction } from '@solana-program/token';
 import { pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageComputeUnitLimit, setTransactionMessageComputeUnitPrice, appendTransactionMessageInstructions, signTransactionMessageWithSigners, address, AccountRole, getProgramDerivedAddress, assertAccountExists, isAddress, getAddressDecoder, fetchEncodedAccount, decodeAccount, getStructDecoder, fixDecoderSize, getBytesDecoder, getU8Decoder, getOptionDecoder, getU16Decoder, getBooleanDecoder, getI64Decoder } from '@solana/kit';
 import Decimal2 from 'decimal.js-light';
 import { z } from 'zod';
@@ -93,13 +94,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);
   assertAccountExists(maybeAccount);
   return maybeAccount;
 }
-async function fetchMaybeConfig(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount(rpc, address2, config);
+async function fetchMaybeConfig(rpc, address3, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address3, config);
   return decodeConfig(maybeAccount);
 }
 if (process.env.NODE_ENV !== "production") ;
@@ -150,6 +151,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) {
@@ -259,6 +353,12 @@ var SOLANA_ADDRESS_LENGTH_RE = /^.{32,44}$/;
 var lamportsSchema = z.number().int().positive().max(MAX_SAFE_LAMPORTS, `amount must be <= ${MAX_SAFE_LAMPORTS}`);
 var feeAmountSchema = z.number().int().nonnegative().max(MAX_SAFE_LAMPORTS, `fee_amount must be <= ${MAX_SAFE_LAMPORTS}`);
 var solanaAddressSchema = z.string().regex(BASE58_RE, "must be base58").regex(SOLANA_ADDRESS_LENGTH_RE, "must be 32-44 base58 chars");
+var paymentAssetRefSchema = z.object({
+  chain: z.string().min(1),
+  token: z.string().min(1),
+  mint: solanaAddressSchema.optional(),
+  decimals: z.number().int().min(0).max(18)
+});
 var PaymentRequestSchema = z.object({
   recipient: solanaAddressSchema,
   amount: lamportsSchema,
@@ -267,7 +367,8 @@ var PaymentRequestSchema = z.object({
   fee_address: solanaAddressSchema.optional(),
   fee_amount: feeAmountSchema.optional(),
   created_at: z.number().int().positive(),
-  expiry_secs: z.number().int().positive().max(MAX_EXPIRY_SECS_SCHEMA, `expiry_secs must be <= ${MAX_EXPIRY_SECS_SCHEMA}`)
+  expiry_secs: 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;
@@ -349,6 +450,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,
@@ -356,7 +463,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) {
@@ -374,6 +482,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",
@@ -462,7 +580,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
     });
@@ -524,6 +642,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,
@@ -533,6 +661,7 @@ var SolanaPaymentStrategy = class {
         treasury,
         expectedNet,
         feeAmount,
+        mint,
         options?.retries ?? DEFAULTS.VERIFY_RETRIES,
         options?.intervalMs ?? DEFAULTS.VERIFY_INTERVAL_MS
       );
@@ -544,11 +673,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 {
@@ -567,15 +697,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 };
@@ -593,7 +726,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 = address(referenceKey);
     for (let attempt = 0; attempt < retries; attempt++) {
@@ -617,15 +750,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 };
@@ -645,7 +781,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++) {
@@ -657,6 +793,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" };
@@ -689,6 +828,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);
@@ -697,7 +877,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 = address(paymentRequest.recipient);
   const reference = address(paymentRequest.reference);
   const feeAmount = paymentRequest.fee_amount ?? 0;
@@ -707,22 +887,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 = getTransferSolInstruction({
-    source: payerSigner,
-    destination: recipient,
-    amount: BigInt(providerAmount)
+  const asset = resolveAssetFromPaymentRequest(paymentRequest);
+  if (!asset.mint) {
+    const providerTransferIx2 = getTransferSolInstruction({
+      source: payerSigner,
+      destination: recipient,
+      amount: BigInt(providerAmount)
+    });
+    const providerTransferIxWithReference2 = {
+      ...providerTransferIx2,
+      accounts: [
+        ...providerTransferIx2.accounts,
+        { address: reference, role: AccountRole.READONLY }
+      ]
+    };
+    const instructions2 = [providerTransferIxWithReference2];
+    if (paymentRequest.fee_address && feeAmount > 0) {
+      instructions2.push(
+        getTransferSolInstruction({
+          source: payerSigner,
+          destination: address(paymentRequest.fee_address),
+          amount: BigInt(feeAmount)
+        })
+      );
+    }
+    return instructions2;
+  }
+  const mint = address(asset.mint);
+  const payerAddress = payerSigner.address;
+  const [payerAta] = await findAssociatedTokenPda({
+    owner: payerAddress,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    mint
+  });
+  const [recipientAta] = await findAssociatedTokenPda({
+    owner: recipient,
+    tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    mint
+  });
+  const instructions = [];
+  instructions.push(
+    getCreateAssociatedTokenIdempotentInstruction(
+      {
+        payer: payerSigner,
+        ata: recipientAta,
+        owner: recipient,
+        mint
+      },
+      { programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS }
+    )
+  );
+  let treasuryAta;
+  if (paymentRequest.fee_address && feeAmount > 0) {
+    const treasuryOwner = address(paymentRequest.fee_address);
+    [treasuryAta] = await findAssociatedTokenPda({
+      owner: treasuryOwner,
+      tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      mint
+    });
+    instructions.push(
+      getCreateAssociatedTokenIdempotentInstruction(
+        {
+          payer: payerSigner,
+          ata: treasuryAta,
+          owner: treasuryOwner,
+          mint
+        },
+        { programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS }
+      )
+    );
+  }
+  const providerTransferIx = getTransferCheckedInstruction({
+    source: payerAta,
+    mint,
+    destination: recipientAta,
+    authority: payerSigner,
+    amount: BigInt(providerAmount),
+    decimals: asset.decimals
   });
   const providerTransferIxWithReference = {
     ...providerTransferIx,
     accounts: [...providerTransferIx.accounts, { address: reference, role: AccountRole.READONLY }]
   };
-  const instructions = [providerTransferIxWithReference];
-  if (paymentRequest.fee_address && feeAmount > 0) {
+  instructions.push(providerTransferIxWithReference);
+  if (treasuryAta && paymentRequest.fee_address && feeAmount > 0) {
     instructions.push(
-      getTransferSolInstruction({
-        source: payerSigner,
-        destination: address(paymentRequest.fee_address),
-        amount: BigInt(feeAmount)
+      getTransferCheckedInstruction({
+        source: payerAta,
+        mint,
+        destination: treasuryAta,
+        authority: payerSigner,
+        amount: BigInt(feeAmount),
+        decimals: asset.decimals
       })
     );
   }
@@ -2331,6 +2587,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 = address(asset.mint);
+    const ataAccountsToCheck = [];
+    const [recipientAta] = await findAssociatedTokenPda({
+      owner: address(paymentRequest.recipient),
+      tokenProgram: TOKEN_PROGRAM_ADDRESS,
+      mint
+    });
+    ataAccountsToCheck.push(recipientAta);
+    const feeAmount = paymentRequest.fee_amount ?? 0;
+    if (paymentRequest.fee_address && feeAmount > 0) {
+      const [treasuryAta] = await findAssociatedTokenPda({
+        owner: address(paymentRequest.fee_address),
+        tokenProgram: 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 = z.object({
+  chain: z.enum(["solana"]),
+  token: z.string().min(1).max(16).regex(/^[a-z0-9]+$/, "token must be lowercase alphanumeric"),
+  mint: z.string().min(1).max(64).optional(),
+  amount: z.number().positive().finite()
+}).strict();
+var GlobalConfigSchema = z.object({
+  session_spend_limits: z.array(SessionSpendLimitEntrySchema).max(16).optional()
+}).strict();
 function formatSol(lamports) {
   const sol = new Decimal2(lamports).div(LAMPORTS_PER_SOL);
   if (sol.gte(1e6)) {
@@ -2522,6 +2905,6 @@ function makeCensor() {
   };
 }
 
-export { BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, DiscoveryService, ElisymClient, ElisymIdentity, INPUT_REDACT_PATHS, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_PING, KIND_PONG, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, NostrPool, PROTOCOL_FEE_BPS, PROTOCOL_PROGRAM_ID_DEVNET, PROTOCOL_TREASURY, PaymentRequestSchema, PingService, RELAYS, SECRET_REDACT_PATHS, SolanaPaymentStrategy, assertExpiry, assertLamports, buildPaymentInstructions, calculateProtocolFee, clearPriorityFeeCache, clearProtocolConfigCache, createPaymentRequestWithOnchainConfig, createSlidingWindowLimiter, estimatePriorityFeeMicroLamports, formatSol, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parsePaymentRequest, pickPercentileFee, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
+export { BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, DiscoveryService, ElisymClient, ElisymIdentity, GlobalConfigSchema, INPUT_REDACT_PATHS, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_PING, KIND_PONG, KNOWN_ASSETS, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, NATIVE_SOL, NostrPool, PROTOCOL_FEE_BPS, PROTOCOL_PROGRAM_ID_DEVNET, PROTOCOL_TREASURY, PaymentRequestSchema, PingService, RELAYS, SECRET_REDACT_PATHS, SessionSpendLimitEntrySchema, SolanaPaymentStrategy, USDC_SOLANA_DEVNET, assertExpiry, assertLamports, assetByKey, assetKey, buildPaymentInstructions, calculateProtocolFee, clearPriorityFeeCache, clearProtocolConfigCache, createPaymentRequestWithOnchainConfig, createSlidingWindowLimiter, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, formatAssetAmount, formatFeeBreakdown, formatSol, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parseAssetAmount, parsePaymentRequest, pickPercentileFee, resolveAssetFromPaymentRequest, resolveKnownAsset, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map