@elisym/sdk 0.5.0 → 0.7.0

package/dist/index.cjs

@@ -3,6 +3,7 @@
 var system = require('@solana-program/system');
 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');
 
@@ -215,7 +216,118 @@ function assertExpiry(createdAt, expirySecs) {
   }
 }
 
+// src/payment/priorityFee.ts
+var PRIORITY_FEE_FLOOR_MICROLAMPORTS = 1000n;
+var DEFAULT_PERCENTILE = 75;
+var DEFAULT_CACHE_TTL_MS = 1e4;
+var cache2 = /* @__PURE__ */ new Map();
+async function estimatePriorityFeeMicroLamports(rpc, options) {
+  const percentile = clampPercentile(options?.percentile ?? DEFAULT_PERCENTILE);
+  const ttl = options?.ttlMs ?? DEFAULT_CACHE_TTL_MS;
+  const accounts = options?.accounts ?? [];
+  const key = cacheKey(percentile, accounts);
+  const now = Date.now();
+  const cached = cache2.get(key);
+  if (cached && now < cached.expires) {
+    return cached.microLamports;
+  }
+  const samples = await rpc.getRecentPrioritizationFees(accounts).send();
+  const fee = pickPercentileFee(samples, percentile);
+  cache2.set(key, { microLamports: fee, expires: now + ttl });
+  return fee;
+}
+function clearPriorityFeeCache() {
+  cache2.clear();
+}
+function pickPercentileFee(samples, percentile) {
+  if (samples.length === 0) {
+    return PRIORITY_FEE_FLOOR_MICROLAMPORTS;
+  }
+  const sorted = samples.map((sample) => BigInt(sample.prioritizationFee)).sort(compareBigInt);
+  const clamped = clampPercentile(percentile);
+  const indexFloat = clamped / 100 * (sorted.length - 1) | 0;
+  const value = sorted[indexFloat];
+  return value > PRIORITY_FEE_FLOOR_MICROLAMPORTS ? value : PRIORITY_FEE_FLOOR_MICROLAMPORTS;
+}
+function clampPercentile(value) {
+  if (!Number.isFinite(value)) {
+    return DEFAULT_PERCENTILE;
+  }
+  if (value < 0) {
+    return 0;
+  }
+  if (value > 100) {
+    return 100;
+  }
+  return value;
+}
+function compareBigInt(left, right) {
+  if (left < right) {
+    return -1;
+  }
+  if (left > right) {
+    return 1;
+  }
+  return 0;
+}
+function cacheKey(percentile, accounts) {
+  if (accounts.length === 0) {
+    return `p:${percentile}`;
+  }
+  return `p:${percentile}:${[...accounts].sort().join(",")}`;
+}
+var MAX_DESCRIPTION_LENGTH = LIMITS.MAX_DESCRIPTION_LENGTH;
+var MAX_SAFE_LAMPORTS = Number.MAX_SAFE_INTEGER;
+var MAX_EXPIRY_SECS_SCHEMA = 86400;
+var BASE58_RE = /^[1-9A-HJ-NP-Za-km-z]+$/;
+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 PaymentRequestSchema = zod.z.object({
+  recipient: solanaAddressSchema,
+  amount: lamportsSchema,
+  reference: solanaAddressSchema,
+  description: zod.z.string().max(MAX_DESCRIPTION_LENGTH).optional(),
+  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}`)
+});
+function parsePaymentRequest(input, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch (e) {
+    return {
+      ok: false,
+      error: { code: "invalid_json", message: `Invalid payment request JSON: ${e}` }
+    };
+  }
+  const result = PaymentRequestSchema.safeParse(parsed);
+  if (!result.success) {
+    return {
+      ok: false,
+      error: { code: "schema", message: result.error.message }
+    };
+  }
+  if (options?.maxAmountLamports !== void 0) {
+    if (BigInt(result.data.amount) > options.maxAmountLamports) {
+      return {
+        ok: false,
+        error: {
+          code: "amount_exceeds_max",
+          message: `Payment amount ${result.data.amount} lamports exceeds approved max ${options.maxAmountLamports}.`
+        }
+      };
+    }
+  }
+  return { ok: true, data: result.data };
+}
+
 // src/payment/solana.ts
+var DEFAULT_COMPUTE_UNIT_LIMIT = 2e5;
+var DEFAULT_PRIORITY_FEE_PERCENTILE = 75;
 var REFERENCE_BYTE_LENGTH = 32;
 function isValidSolanaAddress(value) {
   return kit.isAddress(value);
@@ -272,32 +384,27 @@ var SolanaPaymentStrategy = class {
       expiry_secs: expirySecs
     };
   }
-  validatePaymentRequest(requestJson, config, expectedRecipient) {
+  validatePaymentRequest(requestJson, config, expectedRecipient, options) {
     assertConfig(config);
-    let data;
-    try {
-      data = JSON.parse(requestJson);
-    } catch (e) {
-      return { code: "invalid_json", message: `Invalid payment request JSON: ${e}` };
-    }
-    if (typeof data.amount !== "number" || !Number.isInteger(data.amount) || data.amount <= 0) {
-      return {
-        code: "invalid_amount",
-        message: `Invalid amount in payment request: ${data.amount}`
-      };
-    }
-    if (typeof data.recipient !== "string" || !data.recipient) {
-      return { code: "missing_recipient", message: "Missing recipient in payment request" };
+    const parsed = parsePaymentRequest(requestJson, {
+      maxAmountLamports: options?.maxAmountLamports
+    });
+    if (!parsed.ok) {
+      if (parsed.error.code === "invalid_json") {
+        return { code: "invalid_json", message: parsed.error.message };
+      }
+      if (parsed.error.code === "amount_exceeds_max") {
+        return { code: "invalid_amount", message: parsed.error.message };
+      }
+      return { code: "invalid_amount", message: parsed.error.message };
     }
+    const data = parsed.data;
     if (!isValidSolanaAddress(data.recipient)) {
       return {
         code: "invalid_recipient_address",
         message: `Invalid Solana address for recipient: ${data.recipient}`
       };
     }
-    if (typeof data.reference !== "string" || !data.reference) {
-      return { code: "missing_reference", message: "Missing reference in payment request" };
-    }
     if (!isValidSolanaAddress(data.reference)) {
       return {
         code: "invalid_reference_address",
@@ -357,7 +464,7 @@ var SolanaPaymentStrategy = class {
    * read-only, non-signer account so providers can detect the payment via
    * `getSignaturesForAddress(reference)`.
    */
-  async buildTransaction(paymentRequest, payerSigner, rpc, config) {
+  async buildTransaction(paymentRequest, payerSigner, rpc, config, options) {
     assertConfig(config);
     assertLamports(paymentRequest.amount, "payment amount");
     if (paymentRequest.amount === 0) {
@@ -376,14 +483,23 @@ var SolanaPaymentStrategy = class {
         `Invalid fee address: expected ${treasury}, got ${paymentRequest.fee_address}. Cannot build transaction with redirected fees.`
       );
     }
-    const instructions = buildPaymentInstructions(paymentRequest, payerSigner);
+    const computeUnitLimit = options?.computeUnitLimit ?? DEFAULT_COMPUTE_UNIT_LIMIT;
+    if (!Number.isInteger(computeUnitLimit) || computeUnitLimit <= 0) {
+      throw new Error(`Invalid computeUnitLimit: ${computeUnitLimit}. Must be a positive integer.`);
+    }
+    const paymentInstructions = buildPaymentInstructions(paymentRequest, payerSigner);
+    const priorityFeeMicroLamports = options?.priorityFeeMicroLamports ?? await estimatePriorityFeeMicroLamports(rpc, {
+      percentile: options?.priorityFeePercentile ?? DEFAULT_PRIORITY_FEE_PERCENTILE
+    });
     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.setTransactionMessageComputeUnitLimit(computeUnitLimit, m),
+      (m) => kit.setTransactionMessageComputeUnitPrice(priorityFeeMicroLamports, m),
       (m) => kit.appendTransactionMessageInstructions(
-        instructions,
+        paymentInstructions,
         m
       )
     );
@@ -2296,12 +2412,149 @@ function validateAgentName(name) {
   }
 }
 
+// src/primitives/rateLimiter.ts
+function createSlidingWindowLimiter(options) {
+  const { windowMs, maxPerWindow, maxKeys } = options;
+  if (windowMs <= 0) {
+    throw new RangeError("windowMs must be > 0");
+  }
+  if (maxPerWindow <= 0) {
+    throw new RangeError("maxPerWindow must be > 0");
+  }
+  if (maxKeys <= 0) {
+    throw new RangeError("maxKeys must be > 0");
+  }
+  const entries = /* @__PURE__ */ new Map();
+  function evictIfNeeded() {
+    while (entries.size > maxKeys) {
+      const oldestKey = entries.keys().next().value;
+      if (oldestKey === void 0) {
+        return;
+      }
+      entries.delete(oldestKey);
+    }
+  }
+  return {
+    peek(key, now = Date.now()) {
+      const entry = entries.get(key);
+      if (!entry) {
+        return { allowed: true, resetAt: now + windowMs, count: 0 };
+      }
+      const cutoff = now - windowMs;
+      const fresh = entry.hits.filter((timestamp) => timestamp > cutoff);
+      return {
+        allowed: fresh.length < maxPerWindow,
+        resetAt: (fresh[0] ?? now) + windowMs,
+        count: fresh.length
+      };
+    },
+    check(key, now = Date.now()) {
+      const entry = entries.get(key) ?? { hits: [] };
+      const cutoff = now - windowMs;
+      const fresh = entry.hits.filter((timestamp) => timestamp > cutoff);
+      if (fresh.length >= maxPerWindow) {
+        entries.delete(key);
+        entries.set(key, { hits: fresh });
+        return {
+          allowed: false,
+          resetAt: (fresh[0] ?? now) + windowMs,
+          count: fresh.length
+        };
+      }
+      fresh.push(now);
+      entries.delete(key);
+      entries.set(key, { hits: fresh });
+      evictIfNeeded();
+      return {
+        allowed: true,
+        resetAt: (fresh[0] ?? now) + windowMs,
+        count: fresh.length
+      };
+    },
+    prune(now = Date.now()) {
+      const cutoff = now - windowMs;
+      for (const [key, entry] of entries) {
+        const fresh = entry.hits.filter((timestamp) => timestamp > cutoff);
+        if (fresh.length === 0) {
+          entries.delete(key);
+        } else if (fresh.length !== entry.hits.length) {
+          entry.hits = fresh;
+        }
+      }
+    },
+    size() {
+      return entries.size;
+    },
+    reset() {
+      entries.clear();
+    }
+  };
+}
+
+// src/primitives/logRedact.ts
+var SECRET_REDACT_PATHS = [
+  "*.ELISYM_NOSTR_PRIVATE_KEY",
+  "*.ELISYM_SOLANA_PRIVATE_KEY",
+  "*.nostrPrivateKeyHex",
+  "*.solanaPrivateKeyBase58",
+  "*.secretKey",
+  "*.secret",
+  "ELISYM_NOSTR_PRIVATE_KEY",
+  "ELISYM_SOLANA_PRIVATE_KEY",
+  // Canonical on-disk `.secrets.json` field names. Logging the whole
+  // `secrets` object, or any single field directly, must not leak.
+  "llm_api_key",
+  "nostr_secret_key",
+  "solana_secret_key",
+  "*.llm_api_key",
+  "*.nostr_secret_key",
+  "*.solana_secret_key",
+  "secrets",
+  "*.secrets"
+];
+var INPUT_REDACT_PATHS = [
+  "content",
+  "input",
+  "prompt",
+  "*.content",
+  "*.input",
+  "*.prompt",
+  "event.content",
+  "*.event.content",
+  // JobLedger entries carry the raw Nostr event JSON (which embeds
+  // `event.content`) and the full LLM `resultContent` - both are
+  // customer-confidential and must never land in a structured log.
+  "rawEventJson",
+  "resultContent",
+  "*.rawEventJson",
+  "*.resultContent"
+];
+var DEFAULT_REDACT_PATHS = [...SECRET_REDACT_PATHS, ...INPUT_REDACT_PATHS];
+var INPUT_REDACT_LEAVES = /* @__PURE__ */ new Set([
+  "content",
+  "input",
+  "prompt",
+  "rawEventJson",
+  "resultContent"
+]);
+function makeCensor() {
+  return (_value, path) => {
+    const last = path[path.length - 1];
+    if (last !== void 0 && INPUT_REDACT_LEAVES.has(last)) {
+      return "[INPUT REDACTED]";
+    }
+    return "[REDACTED]";
+  };
+}
+
 exports.BoundedSet = BoundedSet;
 exports.DEFAULTS = DEFAULTS;
 exports.DEFAULT_KIND_OFFSET = DEFAULT_KIND_OFFSET;
+exports.DEFAULT_REDACT_PATHS = DEFAULT_REDACT_PATHS;
 exports.DiscoveryService = DiscoveryService;
 exports.ElisymClient = ElisymClient;
 exports.ElisymIdentity = ElisymIdentity;
+exports.INPUT_REDACT_PATHS = INPUT_REDACT_PATHS;
 exports.KIND_APP_HANDLER = KIND_APP_HANDLER;
 exports.KIND_JOB_FEEDBACK = KIND_JOB_FEEDBACK;
 exports.KIND_JOB_REQUEST = KIND_JOB_REQUEST;
@@ -2318,22 +2571,30 @@ 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.PaymentRequestSchema = PaymentRequestSchema;
 exports.PingService = PingService;
 exports.RELAYS = RELAYS;
+exports.SECRET_REDACT_PATHS = SECRET_REDACT_PATHS;
 exports.SolanaPaymentStrategy = SolanaPaymentStrategy;
 exports.assertExpiry = assertExpiry;
 exports.assertLamports = assertLamports;
 exports.buildPaymentInstructions = buildPaymentInstructions;
 exports.calculateProtocolFee = calculateProtocolFee;
+exports.clearPriorityFeeCache = clearPriorityFeeCache;
 exports.clearProtocolConfigCache = clearProtocolConfigCache;
 exports.createPaymentRequestWithOnchainConfig = createPaymentRequestWithOnchainConfig;
+exports.createSlidingWindowLimiter = createSlidingWindowLimiter;
+exports.estimatePriorityFeeMicroLamports = estimatePriorityFeeMicroLamports;
 exports.formatSol = formatSol;
 exports.getProtocolConfig = getProtocolConfig;
 exports.getProtocolProgramId = getProtocolProgramId;
 exports.jobRequestKind = jobRequestKind;
 exports.jobResultKind = jobResultKind;
+exports.makeCensor = makeCensor;
 exports.nip44Decrypt = nip44Decrypt;
 exports.nip44Encrypt = nip44Encrypt;
+exports.parsePaymentRequest = parsePaymentRequest;
+exports.pickPercentileFee = pickPercentileFee;
 exports.timeAgo = timeAgo;
 exports.toDTag = toDTag;
 exports.truncateKey = truncateKey;