@elisym/sdk 0.8.0 → 0.10.0

package/dist/index.cjs

@@ -1,15 +1,12 @@
 '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');
 var nostrTools = require('nostr-tools');
 var nip44 = require('nostr-tools/nip44');
-var promises = require('fs/promises');
-var YAML2 = require('yaml');
-var crypto$1 = require('crypto');
-var path = require('path');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -33,7 +30,6 @@ function _interopNamespace(e) {
 
 var Decimal2__default = /*#__PURE__*/_interopDefault(Decimal2);
 var nip44__namespace = /*#__PURE__*/_interopNamespace(nip44);
-var YAML2__default = /*#__PURE__*/_interopDefault(YAML2);
 
 // src/constants.ts
 var RELAYS = [
@@ -79,7 +75,7 @@ function getProtocolProgramId(cluster) {
 }
 var DEFAULTS = {
   SUBSCRIPTION_TIMEOUT_MS: 12e4,
-  PING_TIMEOUT_MS: 15e3,
+  PING_TIMEOUT_MS: 3e3,
   PING_RETRIES: 2,
   PING_CACHE_TTL_MS: 3e4,
   PAYMENT_EXPIRY_SECS: 600,
@@ -123,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") ;
@@ -180,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) {
@@ -289,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,
@@ -297,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;
@@ -379,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,
@@ -386,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) {
@@ -404,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",
@@ -492,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
     });
@@ -554,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,
@@ -563,6 +686,7 @@ var SolanaPaymentStrategy = class {
         treasury,
         expectedNet,
         feeAmount,
+        mint,
         options?.retries ?? DEFAULTS.VERIFY_RETRIES,
         options?.intervalMs ?? DEFAULTS.VERIFY_INTERVAL_MS
       );
@@ -574,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 {
@@ -597,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 };
@@ -623,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++) {
@@ -647,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 };
@@ -675,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++) {
@@ -687,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" };
@@ -719,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);
@@ -727,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;
@@ -737,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
       })
     );
   }
@@ -768,6 +1019,95 @@ async function createPaymentRequestWithOnchainConfig(rpc, programId, recipient,
     options
   );
 }
+var NEGATIVE_CACHE_TTL_MS = 6e4;
+var verifyCache = /* @__PURE__ */ new Map();
+function clearQuickVerifyCache() {
+  verifyCache.clear();
+}
+async function verifyJobPaymentQuick(rpc, txSignature, expectedRecipient) {
+  if (!txSignature) {
+    return { verified: false, txSignature: "", reason: "invalid_input" };
+  }
+  if (!expectedRecipient || !kit.isAddress(expectedRecipient)) {
+    return { verified: false, txSignature, reason: "invalid_input" };
+  }
+  const cacheKey2 = `${txSignature}:${expectedRecipient}`;
+  const cached = verifyCache.get(cacheKey2);
+  if (cached) {
+    if (cached.result.verified) {
+      return cached.result;
+    }
+    if (Date.now() - cached.cachedAt < NEGATIVE_CACHE_TTL_MS) {
+      return cached.result;
+    }
+  }
+  const result = await doVerifyOnce(rpc, txSignature, expectedRecipient);
+  verifyCache.set(cacheKey2, { result, cachedAt: Date.now() });
+  return result;
+}
+async function doVerifyOnce(rpc, txSignature, expectedRecipient) {
+  const sigStr = txSignature;
+  if (!rpc || typeof rpc.getTransaction !== "function") {
+    return { verified: false, txSignature: sigStr, reason: "rpc_error" };
+  }
+  let tx;
+  try {
+    tx = await rpc.getTransaction(txSignature, {
+      commitment: "confirmed",
+      encoding: "json",
+      maxSupportedTransactionVersion: 0
+    }).send();
+  } catch {
+    return { verified: false, txSignature: sigStr, reason: "rpc_error" };
+  }
+  if (!tx) {
+    return { verified: false, txSignature: sigStr, reason: "not_found" };
+  }
+  if (!tx.meta || tx.meta.err) {
+    return { verified: false, txSignature: sigStr, reason: "tx_failed" };
+  }
+  const accountKeys = tx.transaction.message.accountKeys;
+  const recipientStr = expectedRecipient;
+  const recipientIdx = accountKeys.indexOf(recipientStr);
+  if (recipientIdx !== -1) {
+    const preBalances = tx.meta.preBalances;
+    const postBalances = tx.meta.postBalances;
+    if (preBalances && postBalances) {
+      const pre = preBalances[recipientIdx];
+      const post = postBalances[recipientIdx];
+      if (pre !== void 0 && post !== void 0) {
+        const delta = BigInt(post) - BigInt(pre);
+        if (delta > 0n) {
+          return { verified: true, txSignature: sigStr };
+        }
+      }
+    }
+  }
+  const postTokenBalances = tx.meta.postTokenBalances;
+  const preTokenBalances = tx.meta.preTokenBalances;
+  if (postTokenBalances) {
+    for (const post of postTokenBalances) {
+      if (post.owner !== recipientStr) {
+        continue;
+      }
+      const pre = preTokenBalances?.find(
+        (entry) => entry.owner === recipientStr && entry.mint === post.mint
+      );
+      const preAmount = pre ? BigInt(pre.uiTokenAmount.amount) : 0n;
+      const postAmount = BigInt(post.uiTokenAmount.amount);
+      if (postAmount > preAmount) {
+        return { verified: true, txSignature: sigStr };
+      }
+    }
+  }
+  return { verified: false, txSignature: sigStr, reason: "recipient_mismatch" };
+}
+
+// src/services/discovery.ts
+var RANKING_ACTIVITY_WINDOW_SECS = 30 * 24 * 60 * 60;
+var RANKING_BUCKET_SIZE_SECS = 60;
+var COLD_START_BUCKET = -Infinity;
+var MAX_PAID_CANDIDATES_PER_AGENT = 5;
 function toDTag(name) {
   const tag = name.toLowerCase().replace(/[^a-z0-9\s-]/g, (ch) => "_" + ch.charCodeAt(0).toString(16).padStart(2, "0")).replace(/\s+/g, "-").replace(/^-+|-+$/g, "");
   if (!tag) {
@@ -775,6 +1115,28 @@ function toDTag(name) {
   }
   return tag;
 }
+function computeRankKey(agent) {
+  const lastPaidJobAt = agent.lastPaidJobAt ?? 0;
+  const total = agent.totalRatingCount ?? 0;
+  const positive = agent.positiveCount ?? 0;
+  const rate = total > 0 ? positive / total : 0;
+  const bucket = lastPaidJobAt > 0 ? Math.floor(lastPaidJobAt / RANKING_BUCKET_SIZE_SECS) * RANKING_BUCKET_SIZE_SECS : COLD_START_BUCKET;
+  return { bucket, rate, lastPaidJobAt, lastSeen: agent.lastSeen };
+}
+function compareAgentsByRank(a, b) {
+  const ka = computeRankKey(a);
+  const kb = computeRankKey(b);
+  if (kb.bucket !== ka.bucket) {
+    return kb.bucket - ka.bucket;
+  }
+  if (kb.rate !== ka.rate) {
+    return kb.rate - ka.rate;
+  }
+  if (kb.lastPaidJobAt !== ka.lastPaidJobAt) {
+    return kb.lastPaidJobAt - ka.lastPaidJobAt;
+  }
+  return kb.lastSeen - ka.lastSeen;
+}
 function buildAgentsFromEvents(events, network) {
   const latestByDTag = /* @__PURE__ */ new Map();
   for (const event of events) {
@@ -869,9 +1231,37 @@ function buildAgentsFromEvents(events, network) {
   }
   return agentMap;
 }
+function pickSolanaAddress(agent) {
+  for (const card of agent.cards) {
+    const addr = card.payment?.address;
+    if (card.payment?.chain === "solana" && typeof addr === "string" && addr.length > 0) {
+      return addr;
+    }
+  }
+  return null;
+}
+async function verifyNewestPaidCandidate(rpc, recipient, candidatesNewestFirst) {
+  const settled = await Promise.allSettled(
+    candidatesNewestFirst.map(
+      (candidate) => verifyJobPaymentQuick(rpc, candidate.txSignature, recipient)
+    )
+  );
+  for (let i = 0; i < settled.length; i++) {
+    const entry = settled[i];
+    if (entry?.status === "fulfilled" && entry.value.verified) {
+      return candidatesNewestFirst[i] ?? null;
+    }
+  }
+  return null;
+}
 var DiscoveryService = class {
-  constructor(pool) {
+  constructor(pool, defaultRpc) {
     this.pool = pool;
+    this.defaultRpc = defaultRpc;
+  }
+  /** Configure the Solana RPC used for on-chain payment verification in `fetchAgents`. */
+  setRpc(rpc) {
+    this.defaultRpc = rpc;
   }
   /** Count elisym agents (kind:31990 with "elisym" tag). */
   async fetchAllAgentCount() {
@@ -959,8 +1349,21 @@ var DiscoveryService = class {
     }
     return agents;
   }
-  /** Fetch elisym agents filtered by network. */
-  async fetchAgents(network = "devnet", limit) {
+  /**
+   * Fetch elisym agents filtered by network, ranked by verified paid-job recency.
+   *
+   * Ranking algorithm:
+   * 1. Bucket each agent into 1-minute slots by `lastPaidJobAt` (last on-chain
+   *    verified payment). Cold-start agents (no verified paid job) go into a
+   *    sentinel bucket below all populated buckets.
+   * 2. Within a bucket, sort by positive review rate descending.
+   * 3. Tiebreak by raw `lastPaidJobAt`, then `lastSeen` (NIP-89 freshness).
+   *
+   * On-chain verification uses {@link verifyJobPaymentQuick} - one-shot, cached.
+   * If `rpc` is not configured, all agents fall through to cold-start and order
+   * is determined by `lastSeen` only.
+   */
+  async fetchAgents(network = "devnet", limit, rpcOverride) {
     const filter = {
       kinds: [KIND_APP_HANDLER],
       "#t": ["elisym"]
@@ -970,40 +1373,100 @@ var DiscoveryService = class {
     }
     const events = await this.pool.querySync(filter);
     const agentMap = buildAgentsFromEvents(events, network);
-    const agents = Array.from(agentMap.values()).sort((a, b) => b.lastSeen - a.lastSeen);
+    const agents = Array.from(agentMap.values());
     const agentPubkeys = Array.from(agentMap.keys());
-    if (agentPubkeys.length > 0) {
-      const activitySince = Math.floor(Date.now() / 1e3) - 24 * 60 * 60;
-      const resultKinds = /* @__PURE__ */ new Set();
-      for (const agent of agentMap.values()) {
-        for (const k of agent.supportedKinds) {
-          if (k >= KIND_JOB_REQUEST_BASE && k < KIND_JOB_RESULT_BASE) {
-            resultKinds.add(KIND_JOB_RESULT_BASE + (k - KIND_JOB_REQUEST_BASE));
-          }
+    if (agentPubkeys.length === 0) {
+      return agents;
+    }
+    const activitySince = Math.floor(Date.now() / 1e3) - RANKING_ACTIVITY_WINDOW_SECS;
+    const resultKinds = /* @__PURE__ */ new Set();
+    for (const agent of agentMap.values()) {
+      for (const k of agent.supportedKinds) {
+        if (k >= KIND_JOB_REQUEST_BASE && k < KIND_JOB_RESULT_BASE) {
+          resultKinds.add(KIND_JOB_RESULT_BASE + (k - KIND_JOB_REQUEST_BASE));
         }
       }
-      resultKinds.add(jobResultKind(DEFAULT_KIND_OFFSET));
-      const [activityEvents] = await Promise.all([
-        this.pool.queryBatched(
-          {
-            kinds: [...resultKinds, KIND_JOB_FEEDBACK],
-            since: activitySince
-          },
-          agentPubkeys
-        ),
-        this.enrichWithMetadata(agents)
-      ]);
-      for (const ev of activityEvents) {
-        if (!nostrTools.verifyEvent(ev)) {
-          continue;
+    }
+    resultKinds.add(jobResultKind(DEFAULT_KIND_OFFSET));
+    const [resultEvents, feedbackEvents] = await Promise.all([
+      this.pool.queryBatched(
+        {
+          kinds: [...resultKinds],
+          since: activitySince
+        },
+        agentPubkeys
+      ),
+      this.pool.queryBatchedByTag(
+        { kinds: [KIND_JOB_FEEDBACK], since: activitySince },
+        "p",
+        agentPubkeys
+      ),
+      this.enrichWithMetadata(agents)
+    ]);
+    for (const ev of resultEvents) {
+      if (!nostrTools.verifyEvent(ev)) {
+        continue;
+      }
+      const agent = agentMap.get(ev.pubkey);
+      if (agent && ev.created_at > agent.lastSeen) {
+        agent.lastSeen = ev.created_at;
+      }
+    }
+    const paidCandidates = /* @__PURE__ */ new Map();
+    for (const ev of feedbackEvents) {
+      if (!nostrTools.verifyEvent(ev)) {
+        continue;
+      }
+      const targetPubkey = ev.tags.find((t) => t[0] === "p")?.[1];
+      if (!targetPubkey) {
+        continue;
+      }
+      const agent = agentMap.get(targetPubkey);
+      if (!agent) {
+        continue;
+      }
+      if (ev.created_at > agent.lastSeen) {
+        agent.lastSeen = ev.created_at;
+      }
+      const rating = ev.tags.find((t) => t[0] === "rating")?.[1];
+      if (rating === "1" || rating === "0") {
+        agent.totalRatingCount = (agent.totalRatingCount ?? 0) + 1;
+        if (rating === "1") {
+          agent.positiveCount = (agent.positiveCount ?? 0) + 1;
         }
-        const agent = agentMap.get(ev.pubkey);
-        if (agent && ev.created_at > agent.lastSeen) {
-          agent.lastSeen = ev.created_at;
+      }
+      const status = ev.tags.find((t) => t[0] === "status")?.[1];
+      const txTag = ev.tags.find((t) => t[0] === "tx");
+      const txSignature = txTag?.[1];
+      if (status === "payment-completed" && typeof txSignature === "string" && txSignature) {
+        const list = paidCandidates.get(targetPubkey);
+        const candidate = { txSignature, createdAt: ev.created_at };
+        if (list) {
+          list.push(candidate);
+        } else {
+          paidCandidates.set(targetPubkey, [candidate]);
         }
       }
-      agents.sort((a, b) => b.lastSeen - a.lastSeen);
     }
+    const rpc = rpcOverride ?? this.defaultRpc;
+    if (rpc && paidCandidates.size > 0) {
+      const perAgent = Array.from(paidCandidates.entries()).map(([agentPubkey, list]) => {
+        const agent = agentMap.get(agentPubkey);
+        const recipient = agent ? pickSolanaAddress(agent) : null;
+        if (!agent || !recipient) {
+          return Promise.resolve();
+        }
+        const ordered = [...list].sort((a, b) => b.createdAt - a.createdAt).slice(0, MAX_PAID_CANDIDATES_PER_AGENT);
+        return verifyNewestPaidCandidate(rpc, recipient, ordered).then((winner) => {
+          if (winner) {
+            agent.lastPaidJobAt = winner.createdAt;
+            agent.lastPaidJobTx = winner.txSignature;
+          }
+        });
+      });
+      await Promise.all(perAgent);
+    }
+    agents.sort(compareAgentsByRank);
     return agents;
   }
   /**
@@ -2351,7 +2814,7 @@ var ElisymClient = class {
   payment;
   constructor(config = {}) {
     this.pool = new NostrPool(config.relays ?? RELAYS);
-    this.discovery = new DiscoveryService(this.pool);
+    this.discovery = new DiscoveryService(this.pool, config.rpc);
     this.marketplace = new MarketplaceService(this.pool);
     this.ping = new PingService(this.pool);
     this.media = new MediaService(config.uploadUrl);
@@ -2361,96 +2824,124 @@ var ElisymClient = class {
     this.pool.close();
   }
 };
-
-// src/payment/assets.ts
-var NATIVE_SOL = {
-  chain: "solana",
-  token: "sol",
-  decimals: 9,
-  symbol: "SOL"
-};
-var KNOWN_ASSETS = [NATIVE_SOL];
-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);
-}
-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)`
-    );
+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);
   }
-  return raw;
+  const totalLamports = baseFeeLamports + priorityFeeLamports + rentLamports;
+  return {
+    baseFeeLamports,
+    priorityFeeLamports,
+    rentLamports,
+    totalLamports,
+    breakdown: {
+      numSignatures,
+      priorityFeeMicroLamports,
+      computeUnitLimit,
+      rentPerAtaLamports,
+      missingAtaCount
+    }
+  };
 }
-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}`;
+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;
   }
-  return `${sign}${whole}.${frac.toString().padStart(asset.decimals, "0")} ${asset.symbol}`;
 }
-async function writeFileAtomic(path$1, data, mode) {
-  await promises.mkdir(path.dirname(path$1), { recursive: true });
-  const tmpPath = `${path$1}.tmp.${crypto$1.randomBytes(6).toString("hex")}`;
-  await promises.writeFile(tmpPath, data, { mode });
-  try {
-    await promises.rename(tmpPath, path$1);
-  } catch (e) {
+async function countMissingAccounts(rpc, accounts) {
+  if (accounts.length === 0) {
+    return 0;
+  }
+  let missing = 0;
+  for (const acct of accounts) {
     try {
-      const { unlink } = await import('fs/promises');
-      await unlink(tmpPath);
+      const res = await rpc.getAccountInfo(acct, { encoding: "base64" }).send();
+      if (!res || !res.value) {
+        missing++;
+      }
     } catch {
+      missing++;
     }
-    throw e;
   }
+  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")}`;
 }
-
-// src/config/global.ts
 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"),
@@ -2460,30 +2951,6 @@ var SessionSpendLimitEntrySchema = zod.z.object({
 var GlobalConfigSchema = zod.z.object({
   session_spend_limits: zod.z.array(SessionSpendLimitEntrySchema).max(16).optional()
 }).strict();
-function isEnoent(e) {
-  return typeof e === "object" && e !== null && "code" in e && e.code === "ENOENT";
-}
-async function loadGlobalConfig(path) {
-  let raw;
-  try {
-    raw = await promises.readFile(path, "utf-8");
-  } catch (e) {
-    if (isEnoent(e)) {
-      return {};
-    }
-    throw e;
-  }
-  if (raw.trim() === "") {
-    return {};
-  }
-  const parsed = YAML2__default.default.parse(raw);
-  return GlobalConfigSchema.parse(parsed ?? {});
-}
-async function writeGlobalConfig(path, config) {
-  const validated = GlobalConfigSchema.parse(config);
-  const body = YAML2__default.default.stringify(validated);
-  await writeFileAtomic(path, body, 420);
-}
 function formatSol(lamports) {
   const sol = new Decimal2__default.default(lamports).div(LAMPORTS_PER_SOL);
   if (sol.gte(1e6)) {
@@ -2708,6 +3175,7 @@ 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;
@@ -2716,28 +3184,33 @@ exports.buildPaymentInstructions = buildPaymentInstructions;
 exports.calculateProtocolFee = calculateProtocolFee;
 exports.clearPriorityFeeCache = clearPriorityFeeCache;
 exports.clearProtocolConfigCache = clearProtocolConfigCache;
+exports.clearQuickVerifyCache = clearQuickVerifyCache;
+exports.compareAgentsByRank = compareAgentsByRank;
+exports.computeRankKey = computeRankKey;
 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;
 exports.jobRequestKind = jobRequestKind;
 exports.jobResultKind = jobResultKind;
-exports.loadGlobalConfig = loadGlobalConfig;
 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;
 exports.validateAgentName = validateAgentName;
 exports.validateExpiry = validateExpiry;
-exports.writeGlobalConfig = writeGlobalConfig;
+exports.verifyJobPaymentQuick = verifyJobPaymentQuick;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map