@elisym/sdk 0.3.2 → 0.4.0

package/dist/index.js

@@ -1,4 +1,5 @@
-import { PublicKey, Keypair, SystemProgram, Transaction } from '@solana/web3.js';
+import { getTransferSolInstruction } from '@solana-program/system';
+import { pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, 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 { verifyEvent, finalizeEvent, getPublicKey, nip19, generateSecretKey, SimplePool } from 'nostr-tools';
 import * as nip44 from 'nostr-tools/nip44';
@@ -35,6 +36,16 @@ var KIND_PONG = 20201;
 var LAMPORTS_PER_SOL = 1e9;
 var PROTOCOL_FEE_BPS = 300;
 var PROTOCOL_TREASURY = "GY7vnWMkKpftU4nQ16C2ATkj1JwrQpHhknkaBUn67VTy";
+var PROTOCOL_PROGRAM_ID_DEVNET = "BrX1CRkSgvcjxBvc2bgc3QqgWjinusofDmeP7ZVxvwrE";
+function getProtocolProgramId(cluster) {
+  switch (cluster) {
+    case "devnet":
+    case "localnet":
+      return PROTOCOL_PROGRAM_ID_DEVNET;
+    case "mainnet":
+      throw new Error("Protocol program is not deployed on mainnet yet");
+  }
+}
 var DEFAULTS = {
   SUBSCRIPTION_TIMEOUT_MS: 12e4,
   PING_TIMEOUT_MS: 15e3,
@@ -61,19 +72,100 @@ var LIMITS = {
   MAX_AGENT_NAME_LENGTH: 64,
   MAX_CAPABILITY_LENGTH: 64
 };
+function getConfigDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["version", getU8Decoder()],
+    ["bump", getU8Decoder()],
+    ["admin", getAddressDecoder()],
+    ["pendingAdmin", getOptionDecoder(getAddressDecoder())],
+    ["treasury", getAddressDecoder()],
+    ["feeBps", getU16Decoder()],
+    ["paused", getBooleanDecoder()],
+    ["lastUpdated", getI64Decoder()],
+    ["reserved", fixDecoderSize(getBytesDecoder(), 128)]
+  ]);
+}
+function decodeConfig(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getConfigDecoder()
+  );
+}
+async function fetchConfig(rpc, address2, config) {
+  const maybeAccount = await fetchMaybeConfig(rpc, address2, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeConfig(rpc, address2, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address2, config);
+  return decodeConfig(maybeAccount);
+}
+if (process.env.NODE_ENV !== "production") ;
+var CONFIG_SEED = "config";
+async function deriveConfigAddress(programId) {
+  const [pda] = await getProgramDerivedAddress({
+    programAddress: programId,
+    seeds: [new TextEncoder().encode(CONFIG_SEED)]
+  });
+  return pda;
+}
+
+// src/config/onchain.ts
+var CACHE_TTL_MS = 6e4;
+var cache = /* @__PURE__ */ new Map();
+function clearProtocolConfigCache() {
+  cache.clear();
+}
+async function getProtocolConfig(rpc, programId, options) {
+  const key = programId.toString();
+  const ttl = options?.ttlMs ?? CACHE_TTL_MS;
+  const cached = cache.get(key);
+  if (!options?.forceRefresh && cached && Date.now() < cached.expires) {
+    return { ...cached.config, source: "cache" };
+  }
+  try {
+    const configPda = await deriveConfigAddress(programId);
+    const account = await fetchConfig(rpc, configPda);
+    const data = account.data;
+    const config = {
+      programId,
+      feeBps: data.feeBps,
+      treasury: data.treasury,
+      admin: data.admin,
+      pendingAdmin: data.pendingAdmin.__option === "Some" ? data.pendingAdmin.value : null,
+      paused: data.paused,
+      version: data.version,
+      source: "onchain"
+    };
+    cache.set(key, { config, expires: Date.now() + ttl });
+    return config;
+  } catch (error) {
+    if (cached) {
+      return { ...cached.config, source: "cache" };
+    }
+    throw new Error(
+      `Failed to fetch protocol config from on-chain program ${programId} and no cached value exists. Ensure RPC is reachable and the program is initialized. Cause: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+var BPS_DENOMINATOR = 1e4;
 function assertLamports(value, field) {
   if (!Number.isInteger(value) || value < 0) {
     throw new Error(`Invalid ${field}: ${value}. Must be a non-negative integer.`);
   }
 }
-function calculateProtocolFee(amount) {
+function calculateProtocolFee(amount, feeBps) {
+  if (!Number.isInteger(feeBps) || feeBps < 0) {
+    throw new Error(`Invalid feeBps: ${feeBps}. Must be a non-negative integer.`);
+  }
   if (!Number.isInteger(amount) || amount < 0) {
     throw new Error(`Invalid fee amount: ${amount}. Must be a non-negative integer.`);
   }
-  if (amount === 0) {
+  if (amount === 0 || feeBps === 0) {
     return 0;
   }
-  return new Decimal2(amount).mul(PROTOCOL_FEE_BPS).div(1e4).toDecimalPlaces(0, Decimal2.ROUND_CEIL).toNumber();
+  return new Decimal2(amount).mul(feeBps).div(BPS_DENOMINATOR).toDecimalPlaces(0, Decimal2.ROUND_CEIL).toNumber();
 }
 function validateExpiry(createdAt, expirySecs) {
   if (!Number.isInteger(createdAt) || createdAt <= 0) {
@@ -99,47 +191,64 @@ function assertExpiry(createdAt, expirySecs) {
 }
 
 // src/payment/solana.ts
-function isValidSolanaAddress(address) {
-  try {
-    void new PublicKey(address);
-    return true;
-  } catch {
-    return false;
+var REFERENCE_BYTE_LENGTH = 32;
+function isValidSolanaAddress(value) {
+  return isAddress(value);
+}
+function generateReference() {
+  const bytes = new Uint8Array(REFERENCE_BYTE_LENGTH);
+  globalThis.crypto.getRandomValues(bytes);
+  return getAddressDecoder().decode(bytes);
+}
+function assertReference(reference) {
+  if (!isValidSolanaAddress(reference)) {
+    throw new Error(`Invalid reference address: ${reference}`);
+  }
+}
+function assertExpirySecs(expirySecs) {
+  if (!Number.isInteger(expirySecs) || expirySecs <= 0 || expirySecs > LIMITS.MAX_TIMEOUT_SECS) {
+    throw new Error(`Invalid expiry: ${expirySecs}. Must be integer 1-${LIMITS.MAX_TIMEOUT_SECS}.`);
+  }
+}
+function assertConfig(config) {
+  if (!Number.isInteger(config.feeBps) || config.feeBps < 0) {
+    throw new Error(`Invalid feeBps: ${config.feeBps}. Must be a non-negative integer.`);
+  }
+  if (typeof config.treasury !== "string" || !isValidSolanaAddress(config.treasury)) {
+    throw new Error(`Invalid treasury address: ${String(config.treasury)}`);
   }
 }
 var SolanaPaymentStrategy = class {
   chain = "solana";
-  calculateFee(amount) {
-    return calculateProtocolFee(amount);
+  calculateFee(amount, config) {
+    assertConfig(config);
+    return calculateProtocolFee(amount, config.feeBps);
   }
-  createPaymentRequest(recipientAddress, amount, expirySecs = DEFAULTS.PAYMENT_EXPIRY_SECS) {
-    try {
-      void new PublicKey(recipientAddress);
-    } catch {
+  createPaymentRequest(recipientAddress, amount, config, options) {
+    assertConfig(config);
+    if (!isValidSolanaAddress(recipientAddress)) {
       throw new Error(`Invalid Solana address: ${recipientAddress}`);
     }
     assertLamports(amount, "payment amount");
     if (amount === 0) {
       throw new Error("Invalid payment amount: 0. Must be positive.");
     }
-    if (!Number.isInteger(expirySecs) || expirySecs <= 0 || expirySecs > LIMITS.MAX_TIMEOUT_SECS) {
-      throw new Error(
-        `Invalid expiry: ${expirySecs}. Must be integer 1-${LIMITS.MAX_TIMEOUT_SECS}.`
-      );
-    }
-    const feeAmount = calculateProtocolFee(amount);
-    const reference = Keypair.generate().publicKey.toBase58();
+    const expirySecs = options?.expirySecs ?? DEFAULTS.PAYMENT_EXPIRY_SECS;
+    assertExpirySecs(expirySecs);
+    const feeAmount = calculateProtocolFee(amount, config.feeBps);
+    const reference = generateReference();
     return {
       recipient: recipientAddress,
       amount,
       reference,
-      fee_address: PROTOCOL_TREASURY,
+      fee_address: config.treasury,
       fee_amount: feeAmount,
       created_at: Math.floor(Date.now() / 1e3),
       expiry_secs: expirySecs
     };
   }
-  validatePaymentRequest(requestJson, expectedRecipient) {
+  validatePaymentRequest(requestJson, config, expectedRecipient) {
+    assertConfig(config);
     let data;
     try {
       data = JSON.parse(requestJson);
@@ -181,21 +290,22 @@ var SolanaPaymentStrategy = class {
       const code = expiryError.includes("future") ? "future_timestamp" : "expired";
       return { code, message: expiryError };
     }
-    const expectedFee = calculateProtocolFee(data.amount);
+    const expectedFee = calculateProtocolFee(data.amount, config.feeBps);
+    const treasury = config.treasury;
     const { fee_address, fee_amount } = data;
     const hasFeeAddress = typeof fee_address === "string" && fee_address.length > 0;
     const hasFeeAmount = typeof fee_amount === "number" && fee_amount > 0;
     if (hasFeeAddress && hasFeeAmount) {
-      if (fee_address !== PROTOCOL_TREASURY) {
+      if (fee_address !== treasury) {
         return {
           code: "fee_address_mismatch",
-          message: `Fee address mismatch: expected ${PROTOCOL_TREASURY}, got ${fee_address}. Provider may be attempting to redirect fees.`
+          message: `Fee address mismatch: expected ${treasury}, got ${fee_address}. Provider may be attempting to redirect fees.`
         };
       }
       if (fee_amount !== expectedFee) {
         return {
           code: "fee_amount_mismatch",
-          message: `Fee amount mismatch: expected ${expectedFee} lamports (${PROTOCOL_FEE_BPS}bps of ${data.amount}), got ${fee_amount}. Provider may be tampering with fee.`
+          message: `Fee amount mismatch: expected ${expectedFee} lamports (${config.feeBps}bps of ${data.amount}), got ${fee_amount}. Provider may be tampering with fee.`
         };
       }
       return null;
@@ -203,20 +313,24 @@ var SolanaPaymentStrategy = class {
     if (!hasFeeAddress && (fee_amount === null || fee_amount === void 0 || fee_amount === 0)) {
       return {
         code: "missing_fee",
-        message: `Payment request missing protocol fee (${PROTOCOL_FEE_BPS}bps). Expected fee: ${expectedFee} lamports to ${PROTOCOL_TREASURY}.`
+        message: `Payment request missing protocol fee (${config.feeBps}bps). Expected fee: ${expectedFee} lamports to ${treasury}.`
       };
     }
     return {
       code: "invalid_fee_params",
-      message: `Invalid fee params in payment request. Expected fee: ${expectedFee} lamports to ${PROTOCOL_TREASURY}.`
+      message: `Invalid fee params in payment request. Expected fee: ${expectedFee} lamports to ${treasury}.`
     };
   }
   /**
-   * Build an unsigned transaction from a payment request.
-   * The caller must set `recentBlockhash` and `feePayer` on the
-   * returned Transaction before signing and sending.
+   * Build, sign, and return a transaction for the supplied payment request.
+   * The caller is responsible for sending it (e.g. via `rpc.sendTransaction`).
+   *
+   * The provider transfer instruction includes the payment reference as a
+   * read-only, non-signer account so providers can detect the payment via
+   * `getSignaturesForAddress(reference)`.
    */
-  async buildTransaction(payerAddress, paymentRequest) {
+  async buildTransaction(paymentRequest, payerSigner, rpc, config) {
+    assertConfig(config);
     assertLamports(paymentRequest.amount, "payment amount");
     if (paymentRequest.amount === 0) {
       throw new Error("Invalid payment amount: 0. Must be positive.");
@@ -226,50 +340,32 @@ var SolanaPaymentStrategy = class {
         `Invalid fee amount: ${paymentRequest.fee_amount}. Must be a non-negative integer (lamports).`
       );
     }
+    assertReference(paymentRequest.reference);
     assertExpiry(paymentRequest.created_at, paymentRequest.expiry_secs);
-    if (paymentRequest.fee_address && paymentRequest.fee_address !== PROTOCOL_TREASURY) {
-      throw new Error(
-        `Invalid fee address: expected ${PROTOCOL_TREASURY}, got ${paymentRequest.fee_address}. Cannot build transaction with redirected fees.`
-      );
-    }
-    const payerPubkey = new PublicKey(payerAddress);
-    const recipient = new PublicKey(paymentRequest.recipient);
-    const reference = new PublicKey(paymentRequest.reference);
-    const feeAddress = paymentRequest.fee_address ? new PublicKey(paymentRequest.fee_address) : null;
-    const feeAmount = paymentRequest.fee_amount ?? 0;
-    const providerAmount = feeAddress && feeAmount > 0 ? paymentRequest.amount - feeAmount : paymentRequest.amount;
-    if (providerAmount <= 0) {
+    const treasury = config.treasury;
+    if (paymentRequest.fee_address && paymentRequest.fee_address !== treasury) {
       throw new Error(
-        `Fee amount (${feeAmount}) exceeds or equals total amount (${paymentRequest.amount}). Cannot create transaction with non-positive provider amount.`
+        `Invalid fee address: expected ${treasury}, got ${paymentRequest.fee_address}. Cannot build transaction with redirected fees.`
       );
     }
-    const transferIx = SystemProgram.transfer({
-      fromPubkey: payerPubkey,
-      toPubkey: recipient,
-      lamports: providerAmount
-    });
-    transferIx.keys.push({
-      pubkey: reference,
-      isSigner: false,
-      isWritable: false
-    });
-    const tx = new Transaction().add(transferIx);
-    if (feeAddress && feeAmount > 0) {
-      tx.add(
-        SystemProgram.transfer({
-          fromPubkey: payerPubkey,
-          toPubkey: feeAddress,
-          lamports: feeAmount
-        })
-      );
-    }
-    return tx;
+    const instructions = buildPaymentInstructions(paymentRequest, payerSigner);
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const message = pipe(
+      createTransactionMessage({ version: 0 }),
+      (m) => setTransactionMessageFeePayerSigner(payerSigner, m),
+      (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+      (m) => appendTransactionMessageInstructions(
+        instructions,
+        m
+      )
+    );
+    return signTransactionMessageWithSigners(message);
   }
-  async verifyPayment(connection, paymentRequest, options) {
-    if (!connection || typeof connection.getTransaction !== "function") {
-      return { verified: false, error: "Invalid connection: expected Solana Connection instance" };
+  async verifyPayment(rpc, paymentRequest, config, options) {
+    assertConfig(config);
+    if (!rpc || typeof rpc.getTransaction !== "function") {
+      return { verified: false, error: "Invalid rpc: expected Solana Kit Rpc instance" };
     }
-    const conn = connection;
     if (!paymentRequest.reference || !paymentRequest.recipient) {
       return { verified: false, error: "Missing required fields in payment request" };
     }
@@ -285,19 +381,20 @@ var SolanaPaymentStrategy = class {
         error: `Invalid fee_amount: ${paymentRequest.fee_amount}. Must be a non-negative integer.`
       };
     }
-    const expectedFee = calculateProtocolFee(paymentRequest.amount);
+    const expectedFee = calculateProtocolFee(paymentRequest.amount, config.feeBps);
     const feeAmount = paymentRequest.fee_amount ?? 0;
+    const treasury = config.treasury;
     if (expectedFee > 0) {
       if (feeAmount < expectedFee) {
         return {
           verified: false,
-          error: `Protocol fee ${feeAmount} below required ${expectedFee} (${PROTOCOL_FEE_BPS}bps of ${paymentRequest.amount})`
+          error: `Protocol fee ${feeAmount} below required ${expectedFee} (${config.feeBps}bps of ${paymentRequest.amount})`
         };
       }
       if (!paymentRequest.fee_address) {
         return { verified: false, error: "Missing fee address in payment request" };
       }
-      if (paymentRequest.fee_address !== PROTOCOL_TREASURY) {
+      if (paymentRequest.fee_address !== treasury) {
         return { verified: false, error: `Invalid fee address: ${paymentRequest.fee_address}` };
       }
     }
@@ -310,10 +407,11 @@ var SolanaPaymentStrategy = class {
     }
     if (options?.txSignature) {
       return this._verifyBySignature(
-        conn,
+        rpc,
         options.txSignature,
         paymentRequest.reference,
         paymentRequest.recipient,
+        treasury,
         expectedNet,
         feeAmount,
         options?.retries ?? DEFAULTS.VERIFY_RETRIES,
@@ -321,26 +419,28 @@ var SolanaPaymentStrategy = class {
       );
     }
     return this._verifyByReference(
-      conn,
+      rpc,
       paymentRequest.reference,
       paymentRequest.recipient,
+      treasury,
       expectedNet,
       feeAmount,
       options?.retries ?? DEFAULTS.VERIFY_BY_REF_RETRIES,
       options?.intervalMs ?? DEFAULTS.VERIFY_BY_REF_INTERVAL_MS
     );
   }
-  async _verifyBySignature(connection, txSignature, referenceKey, recipientAddress, expectedNet, expectedFee, retries, intervalMs) {
+  async _verifyBySignature(rpc, txSignature, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, retries, intervalMs) {
     let lastError;
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
-        const tx = await connection.getTransaction(txSignature, {
-          maxSupportedTransactionVersion: 0,
-          commitment: "confirmed"
-        });
+        const tx = await rpc.getTransaction(txSignature, {
+          commitment: "confirmed",
+          encoding: "json",
+          maxSupportedTransactionVersion: 0
+        }).send();
         if (!tx?.meta || tx.meta.err) {
           if (attempt < retries - 1) {
-            await new Promise((r) => setTimeout(r, intervalMs));
+            await waitMs(intervalMs);
             continue;
           }
           return {
@@ -348,50 +448,24 @@ var SolanaPaymentStrategy = class {
             error: tx?.meta?.err ? "Transaction failed on-chain" : "Transaction not found"
           };
         }
-        const accountKeys = tx.transaction.message.getAccountKeys();
-        const balanceCount = tx.meta.preBalances.length;
-        const keyToIdx = /* @__PURE__ */ new Map();
-        for (let i = 0; i < Math.min(accountKeys.length, balanceCount); i++) {
-          const key = accountKeys.get(i);
-          if (key) {
-            keyToIdx.set(key.toBase58(), i);
-          }
-        }
-        if (!keyToIdx.has(referenceKey)) {
-          return {
-            verified: false,
-            error: "Reference key not found in transaction - possible replay"
-          };
-        }
-        const recipientIdx = keyToIdx.get(recipientAddress);
-        if (recipientIdx === void 0) {
-          return { verified: false, error: "Recipient not found in transaction" };
-        }
-        const recipientDelta = (tx.meta.postBalances[recipientIdx] ?? 0) - (tx.meta.preBalances[recipientIdx] ?? 0);
-        if (recipientDelta < expectedNet) {
-          return {
-            verified: false,
-            error: `Recipient received ${recipientDelta}, expected >= ${expectedNet}`
-          };
-        }
-        if (expectedFee > 0) {
-          const treasuryIdx = keyToIdx.get(PROTOCOL_TREASURY);
-          if (treasuryIdx === void 0) {
-            return { verified: false, error: "Treasury not found in transaction" };
-          }
-          const treasuryDelta = (tx.meta.postBalances[treasuryIdx] ?? 0) - (tx.meta.preBalances[treasuryIdx] ?? 0);
-          if (treasuryDelta < expectedFee) {
-            return {
-              verified: false,
-              error: `Treasury received ${treasuryDelta}, expected >= ${expectedFee}`
-            };
-          }
+        const verdict = checkBalanceDiff({
+          accountKeys: tx.transaction.message.accountKeys,
+          preBalances: tx.meta.preBalances,
+          postBalances: tx.meta.postBalances,
+          referenceKey,
+          recipientAddress,
+          treasuryAddress,
+          expectedNet,
+          expectedFee
+        });
+        if (verdict.ok) {
+          return { verified: true, txSignature };
         }
-        return { verified: true, txSignature };
+        return { verified: false, error: verdict.reason };
       } catch (err) {
         lastError = err;
         if (attempt < retries - 1) {
-          await new Promise((r) => setTimeout(r, intervalMs));
+          await waitMs(intervalMs);
         }
       }
     }
@@ -400,66 +474,50 @@ var SolanaPaymentStrategy = class {
       error: `Verification failed after ${retries} retries: ${lastError instanceof Error ? lastError.message : "unknown error"}`
     };
   }
-  async _verifyByReference(connection, referenceKey, recipientAddress, expectedNet, expectedFee, retries, intervalMs) {
-    const reference = new PublicKey(referenceKey);
+  async _verifyByReference(rpc, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, retries, intervalMs) {
     let lastError;
+    const reference = address(referenceKey);
     for (let attempt = 0; attempt < retries; attempt++) {
       try {
-        const signatures = await connection.getSignaturesForAddress(reference, {
+        const signatures = await rpc.getSignaturesForAddress(reference, {
           limit: DEFAULTS.VERIFY_SIGNATURE_LIMIT
-        });
-        const validSigs = signatures.filter((s) => !s.err);
+        }).send();
+        const validSigs = signatures.filter((entry) => !entry.err);
         if (validSigs.length > 0) {
+          const fetchTransaction = (sig) => rpc.getTransaction(sig, {
+            commitment: "confirmed",
+            encoding: "json",
+            maxSupportedTransactionVersion: 0
+          }).send();
           const txResults = await Promise.all(
             validSigs.map(
-              (s) => connection.getTransaction(s.signature, {
-                maxSupportedTransactionVersion: 0,
-                commitment: "confirmed"
-              }).then((tx) => ({ sig: s.signature, tx })).catch(() => ({
-                sig: s.signature,
-                tx: null
-              }))
+              (entry) => fetchTransaction(entry.signature).then((tx) => ({ sig: entry.signature, tx })).catch(() => ({ sig: entry.signature, tx: null }))
             )
           );
           for (const { sig, tx } of txResults) {
             if (!tx?.meta || tx.meta.err) {
               continue;
             }
-            const accountKeys = tx.transaction.message.getAccountKeys();
-            const balanceCount = tx.meta.preBalances.length;
-            const keyToIdx = /* @__PURE__ */ new Map();
-            for (let i = 0; i < Math.min(accountKeys.length, balanceCount); i++) {
-              const key = accountKeys.get(i);
-              if (key) {
-                keyToIdx.set(key.toBase58(), i);
-              }
+            const verdict = checkBalanceDiff({
+              accountKeys: tx.transaction.message.accountKeys,
+              preBalances: tx.meta.preBalances,
+              postBalances: tx.meta.postBalances,
+              referenceKey,
+              recipientAddress,
+              treasuryAddress,
+              expectedNet,
+              expectedFee
+            });
+            if (verdict.ok) {
+              return { verified: true, txSignature: sig };
             }
-            const recipientIdx = keyToIdx.get(recipientAddress);
-            if (recipientIdx === void 0) {
-              continue;
-            }
-            const recipientDelta = (tx.meta.postBalances[recipientIdx] ?? 0) - (tx.meta.preBalances[recipientIdx] ?? 0);
-            if (recipientDelta < expectedNet) {
-              continue;
-            }
-            if (expectedFee > 0) {
-              const treasuryIdx = keyToIdx.get(PROTOCOL_TREASURY);
-              if (treasuryIdx === void 0) {
-                continue;
-              }
-              const treasuryDelta = (tx.meta.postBalances[treasuryIdx] ?? 0) - (tx.meta.preBalances[treasuryIdx] ?? 0);
-              if (treasuryDelta < expectedFee) {
-                continue;
-              }
-            }
-            return { verified: true, txSignature: sig };
           }
         }
       } catch (err) {
         lastError = err;
       }
       if (attempt < retries - 1) {
-        await new Promise((r) => setTimeout(r, intervalMs));
+        await waitMs(intervalMs);
       }
     }
     return {
@@ -468,6 +526,99 @@ var SolanaPaymentStrategy = class {
     };
   }
 };
+function checkBalanceDiff(input) {
+  const balanceCount = input.preBalances.length;
+  const keyToIdx = /* @__PURE__ */ new Map();
+  for (let i = 0; i < Math.min(input.accountKeys.length, balanceCount); i++) {
+    const key = input.accountKeys[i];
+    if (key) {
+      keyToIdx.set(String(key), i);
+    }
+  }
+  if (!keyToIdx.has(input.referenceKey)) {
+    return { ok: false, reason: "Reference key not found in transaction - possible replay" };
+  }
+  const recipientIdx = keyToIdx.get(input.recipientAddress);
+  if (recipientIdx === void 0) {
+    return { ok: false, reason: "Recipient not found in transaction" };
+  }
+  const recipientDelta = bigIntDelta(
+    input.postBalances[recipientIdx],
+    input.preBalances[recipientIdx]
+  );
+  if (recipientDelta < BigInt(input.expectedNet)) {
+    return {
+      ok: false,
+      reason: `Recipient received ${recipientDelta.toString()}, expected >= ${input.expectedNet}`
+    };
+  }
+  if (input.expectedFee > 0) {
+    const treasuryIdx = keyToIdx.get(input.treasuryAddress);
+    if (treasuryIdx === void 0) {
+      return { ok: false, reason: "Treasury not found in transaction" };
+    }
+    const treasuryDelta = bigIntDelta(
+      input.postBalances[treasuryIdx],
+      input.preBalances[treasuryIdx]
+    );
+    if (treasuryDelta < BigInt(input.expectedFee)) {
+      return {
+        ok: false,
+        reason: `Treasury received ${treasuryDelta.toString()}, 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);
+  return postValue - preValue;
+}
+function waitMs(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildPaymentInstructions(paymentRequest, payerSigner) {
+  const recipient = address(paymentRequest.recipient);
+  const reference = address(paymentRequest.reference);
+  const feeAmount = paymentRequest.fee_amount ?? 0;
+  const providerAmount = paymentRequest.fee_address && feeAmount > 0 ? paymentRequest.amount - feeAmount : paymentRequest.amount;
+  if (providerAmount <= 0) {
+    throw new Error(
+      `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 providerTransferIxWithReference = {
+    ...providerTransferIx,
+    accounts: [...providerTransferIx.accounts, { address: reference, role: AccountRole.READONLY }]
+  };
+  const instructions = [providerTransferIxWithReference];
+  if (paymentRequest.fee_address && feeAmount > 0) {
+    instructions.push(
+      getTransferSolInstruction({
+        source: payerSigner,
+        destination: address(paymentRequest.fee_address),
+        amount: BigInt(feeAmount)
+      })
+    );
+  }
+  return instructions;
+}
+async function createPaymentRequestWithOnchainConfig(rpc, programId, recipient, amount, options) {
+  const config = await getProtocolConfig(rpc, programId);
+  const strategy = new SolanaPaymentStrategy();
+  return strategy.createPaymentRequest(
+    recipient,
+    amount,
+    { feeBps: config.feeBps, treasury: config.treasury },
+    options
+  );
+}
 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) {
@@ -1571,12 +1722,18 @@ var PingService = class _PingService {
   constructor(pool) {
     this.pool = pool;
     this.sessionIdentity = ElisymIdentity.generate();
+    pool.onReset(() => this.clearCache());
   }
   static PING_CACHE_MAX = 1e3;
   sessionIdentity;
   pingCache = /* @__PURE__ */ new Map();
   // pubkey - timestamp of last online result
   pendingPings = /* @__PURE__ */ new Map();
+  /** Drop cached online results. In-flight pings are left alone - they'll
+   * resolve via their own timeouts and remove themselves from `pendingPings`. */
+  clearCache() {
+    this.pingCache.clear();
+  }
   /**
    * Ping an agent via ephemeral Nostr events (kind 20200/20201).
    * Uses a persistent session identity to avoid relay rate-limiting.
@@ -1775,10 +1932,28 @@ var NostrPool = class {
   pool;
   relays;
   activeSubscriptions = /* @__PURE__ */ new Set();
+  resetListeners = /* @__PURE__ */ new Set();
   constructor(relays = RELAYS) {
     this.pool = new SimplePool();
     this.relays = relays;
   }
+  /**
+   * Register a callback to run after `reset()` completes (new SimplePool in place).
+   * Services that cache pool-derived state (e.g. ping results) must clear it here,
+   * otherwise stale values survive the reconnect. Returns an unsubscribe function.
+   *
+   * Contract:
+   * - Listeners are invoked **synchronously** at the end of `reset()`, in
+   *   registration order. Do not rely on async work inside a listener having
+   *   completed before `reset()` returns.
+   * - Listener exceptions are caught and swallowed so that one faulty listener
+   *   cannot prevent the others from running (or abort the reset itself).
+   *   If a listener needs to surface errors, it must do so out-of-band.
+   */
+  onReset(listener) {
+    this.resetListeners.add(listener);
+    return () => this.resetListeners.delete(listener);
+  }
   /** Query relays synchronously. Returns `[]` on timeout (no error thrown). */
   async querySync(filter) {
     let timer;
@@ -1786,13 +1961,12 @@ var NostrPool = class {
     query.catch(() => {
     });
     try {
-      const result = await Promise.race([
+      return await Promise.race([
         query,
         new Promise((resolve) => {
           timer = setTimeout(() => resolve([]), DEFAULTS.QUERY_TIMEOUT_MS);
         })
       ]);
-      return result;
     } finally {
       clearTimeout(timer);
     }
@@ -1974,6 +2148,12 @@ var NostrPool = class {
     } catch {
     }
     this.pool = new SimplePool();
+    for (const listener of this.resetListeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
   }
   /**
    * Lightweight connectivity probe. Returns true if at least one relay responds.
@@ -2091,6 +2271,6 @@ function serializeConfig(config) {
   return JSON.stringify(config, null, 2) + "\n";
 }
 
-export { BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DiscoveryService, ElisymClient, ElisymIdentity, 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_TREASURY, PingService, RELAYS, SolanaPaymentStrategy, assertExpiry, assertLamports, calculateProtocolFee, formatSol, jobRequestKind, jobResultKind, nip44Decrypt, nip44Encrypt, serializeConfig, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
+export { BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DiscoveryService, ElisymClient, ElisymIdentity, 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, PingService, RELAYS, SolanaPaymentStrategy, assertExpiry, assertLamports, buildPaymentInstructions, calculateProtocolFee, clearProtocolConfigCache, createPaymentRequestWithOnchainConfig, formatSol, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, nip44Decrypt, nip44Encrypt, serializeConfig, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map