@elisym/sdk 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,6 +1,7 @@
 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 { pipe, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, setTransactionMessageComputeUnitLimit, setTransactionMessageComputeUnitPrice, appendTransactionMessageInstructions, signTransactionMessageWithSigners, address, AccountRole, getProgramDerivedAddress, assertAccountExists, isAddress, getAddressDecoder, fetchEncodedAccount, decodeAccount, getStructDecoder, fixDecoderSize, getBytesDecoder, getU8Decoder, getOptionDecoder, getU16Decoder, getBooleanDecoder, getI64Decoder } from '@solana/kit';
 import Decimal2 from 'decimal.js-light';
+import { z } from 'zod';
 import { verifyEvent, finalizeEvent, getPublicKey, nip19, generateSecretKey, SimplePool } from 'nostr-tools';
 import * as nip44 from 'nostr-tools/nip44';
 
@@ -190,7 +191,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 = z.number().int().positive().max(MAX_SAFE_LAMPORTS, `amount must be <= ${MAX_SAFE_LAMPORTS}`);
+var feeAmountSchema = z.number().int().nonnegative().max(MAX_SAFE_LAMPORTS, `fee_amount must be <= ${MAX_SAFE_LAMPORTS}`);
+var solanaAddressSchema = z.string().regex(BASE58_RE, "must be base58").regex(SOLANA_ADDRESS_LENGTH_RE, "must be 32-44 base58 chars");
+var PaymentRequestSchema = z.object({
+  recipient: solanaAddressSchema,
+  amount: lamportsSchema,
+  reference: solanaAddressSchema,
+  description: z.string().max(MAX_DESCRIPTION_LENGTH).optional(),
+  fee_address: solanaAddressSchema.optional(),
+  fee_amount: feeAmountSchema.optional(),
+  created_at: z.number().int().positive(),
+  expiry_secs: z.number().int().positive().max(MAX_EXPIRY_SECS_SCHEMA, `expiry_secs must be <= ${MAX_EXPIRY_SECS_SCHEMA}`)
+});
+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 isAddress(value);
@@ -247,32 +359,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",
@@ -332,7 +439,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) {
@@ -351,14 +458,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 = pipe(
       createTransactionMessage({ version: 0 }),
       (m) => setTransactionMessageFeePayerSigner(payerSigner, m),
       (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),
+      (m) => setTransactionMessageComputeUnitLimit(computeUnitLimit, m),
+      (m) => setTransactionMessageComputeUnitPrice(priorityFeeMicroLamports, m),
       (m) => appendTransactionMessageInstructions(
-        instructions,
+        paymentInstructions,
         m
       )
     );
@@ -2271,6 +2387,141 @@ function validateAgentName(name) {
   }
 }
 
-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, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
+// 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]";
+  };
+}
+
+export { BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, DiscoveryService, ElisymClient, ElisymIdentity, INPUT_REDACT_PATHS, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_PING, KIND_PONG, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, NostrPool, PROTOCOL_FEE_BPS, PROTOCOL_PROGRAM_ID_DEVNET, PROTOCOL_TREASURY, PaymentRequestSchema, PingService, RELAYS, SECRET_REDACT_PATHS, SolanaPaymentStrategy, assertExpiry, assertLamports, buildPaymentInstructions, calculateProtocolFee, clearPriorityFeeCache, clearProtocolConfigCache, createPaymentRequestWithOnchainConfig, createSlidingWindowLimiter, estimatePriorityFeeMicroLamports, formatSol, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parsePaymentRequest, pickPercentileFee, timeAgo, toDTag, truncateKey, validateAgentName, validateExpiry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map