@elisym/sdk 0.3.3 → 0.4.0

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
-var web3_js = require('@solana/web3.js');
+var system = require('@solana-program/system');
+var kit = require('@solana/kit');
 var Decimal2 = require('decimal.js-light');
 var nostrTools = require('nostr-tools');
 var nip44 = require('nostr-tools/nip44');
@@ -60,6 +61,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,
@@ -86,19 +97,100 @@ var LIMITS = {
   MAX_AGENT_NAME_LENGTH: 64,
   MAX_CAPABILITY_LENGTH: 64
 };
+function getConfigDecoder() {
+  return kit.getStructDecoder([
+    ["discriminator", kit.fixDecoderSize(kit.getBytesDecoder(), 8)],
+    ["version", kit.getU8Decoder()],
+    ["bump", kit.getU8Decoder()],
+    ["admin", kit.getAddressDecoder()],
+    ["pendingAdmin", kit.getOptionDecoder(kit.getAddressDecoder())],
+    ["treasury", kit.getAddressDecoder()],
+    ["feeBps", kit.getU16Decoder()],
+    ["paused", kit.getBooleanDecoder()],
+    ["lastUpdated", kit.getI64Decoder()],
+    ["reserved", kit.fixDecoderSize(kit.getBytesDecoder(), 128)]
+  ]);
+}
+function decodeConfig(encodedAccount) {
+  return kit.decodeAccount(
+    encodedAccount,
+    getConfigDecoder()
+  );
+}
+async function fetchConfig(rpc, address2, config) {
+  const maybeAccount = await fetchMaybeConfig(rpc, address2, config);
+  kit.assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeConfig(rpc, address2, config) {
+  const maybeAccount = await kit.fetchEncodedAccount(rpc, address2, config);
+  return decodeConfig(maybeAccount);
+}
+if (process.env.NODE_ENV !== "production") ;
+var CONFIG_SEED = "config";
+async function deriveConfigAddress(programId) {
+  const [pda] = await kit.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__default.default(amount).mul(PROTOCOL_FEE_BPS).div(1e4).toDecimalPlaces(0, Decimal2__default.default.ROUND_CEIL).toNumber();
+  return new Decimal2__default.default(amount).mul(feeBps).div(BPS_DENOMINATOR).toDecimalPlaces(0, Decimal2__default.default.ROUND_CEIL).toNumber();
 }
 function validateExpiry(createdAt, expirySecs) {
   if (!Number.isInteger(createdAt) || createdAt <= 0) {
@@ -124,47 +216,64 @@ function assertExpiry(createdAt, expirySecs) {
 }
 
 // src/payment/solana.ts
-function isValidSolanaAddress(address) {
-  try {
-    void new web3_js.PublicKey(address);
-    return true;
-  } catch {
-    return false;
+var REFERENCE_BYTE_LENGTH = 32;
+function isValidSolanaAddress(value) {
+  return kit.isAddress(value);
+}
+function generateReference() {
+  const bytes = new Uint8Array(REFERENCE_BYTE_LENGTH);
+  globalThis.crypto.getRandomValues(bytes);
+  return kit.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 web3_js.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 = web3_js.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);
@@ -206,21 +315,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;
@@ -228,20 +338,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.");
@@ -251,50 +365,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 web3_js.PublicKey(payerAddress);
-    const recipient = new web3_js.PublicKey(paymentRequest.recipient);
-    const reference = new web3_js.PublicKey(paymentRequest.reference);
-    const feeAddress = paymentRequest.fee_address ? new web3_js.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.`
-      );
-    }
-    const transferIx = web3_js.SystemProgram.transfer({
-      fromPubkey: payerPubkey,
-      toPubkey: recipient,
-      lamports: providerAmount
-    });
-    transferIx.keys.push({
-      pubkey: reference,
-      isSigner: false,
-      isWritable: false
-    });
-    const tx = new web3_js.Transaction().add(transferIx);
-    if (feeAddress && feeAmount > 0) {
-      tx.add(
-        web3_js.SystemProgram.transfer({
-          fromPubkey: payerPubkey,
-          toPubkey: feeAddress,
-          lamports: feeAmount
-        })
+        `Invalid fee address: expected ${treasury}, got ${paymentRequest.fee_address}. Cannot build transaction with redirected fees.`
       );
     }
-    return tx;
+    const instructions = buildPaymentInstructions(paymentRequest, payerSigner);
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const message = kit.pipe(
+      kit.createTransactionMessage({ version: 0 }),
+      (m) => kit.setTransactionMessageFeePayerSigner(payerSigner, m),
+      (m) => kit.setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+      (m) => kit.appendTransactionMessageInstructions(
+        instructions,
+        m
+      )
+    );
+    return kit.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" };
     }
@@ -310,19 +406,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}` };
       }
     }
@@ -335,10 +432,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,
@@ -346,26 +444,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 {
@@ -373,50 +473,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);
         }
       }
     }
@@ -425,66 +499,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 web3_js.PublicKey(referenceKey);
+  async _verifyByReference(rpc, referenceKey, recipientAddress, treasuryAddress, expectedNet, expectedFee, retries, intervalMs) {
     let lastError;
+    const reference = kit.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 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;
+            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 };
             }
-            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 {
@@ -493,6 +551,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 = kit.address(paymentRequest.recipient);
+  const reference = kit.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 = system.getTransferSolInstruction({
+    source: payerSigner,
+    destination: recipient,
+    amount: BigInt(providerAmount)
+  });
+  const providerTransferIxWithReference = {
+    ...providerTransferIx,
+    accounts: [...providerTransferIx.accounts, { address: reference, role: kit.AccountRole.READONLY }]
+  };
+  const instructions = [providerTransferIxWithReference];
+  if (paymentRequest.fee_address && feeAmount > 0) {
+    instructions.push(
+      system.getTransferSolInstruction({
+        source: payerSigner,
+        destination: kit.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) {
@@ -2165,14 +2316,20 @@ exports.MarketplaceService = MarketplaceService;
 exports.MediaService = MediaService;
 exports.NostrPool = NostrPool;
 exports.PROTOCOL_FEE_BPS = PROTOCOL_FEE_BPS;
+exports.PROTOCOL_PROGRAM_ID_DEVNET = PROTOCOL_PROGRAM_ID_DEVNET;
 exports.PROTOCOL_TREASURY = PROTOCOL_TREASURY;
 exports.PingService = PingService;
 exports.RELAYS = RELAYS;
 exports.SolanaPaymentStrategy = SolanaPaymentStrategy;
 exports.assertExpiry = assertExpiry;
 exports.assertLamports = assertLamports;
+exports.buildPaymentInstructions = buildPaymentInstructions;
 exports.calculateProtocolFee = calculateProtocolFee;
+exports.clearProtocolConfigCache = clearProtocolConfigCache;
+exports.createPaymentRequestWithOnchainConfig = createPaymentRequestWithOnchainConfig;
 exports.formatSol = formatSol;
+exports.getProtocolConfig = getProtocolConfig;
+exports.getProtocolProgramId = getProtocolProgramId;
 exports.jobRequestKind = jobRequestKind;
 exports.jobResultKind = jobResultKind;
 exports.nip44Decrypt = nip44Decrypt;