@elisym/sdk 0.25.0 → 0.25.1

package/dist/index.js

@@ -75,7 +75,9 @@ var DEFAULTS = {
   IROH_FETCH_TIMEOUT_MS: 3e5,
   // Ceiling for a single Blossom blob upload (PUT /upload). Large blobs (up to
   // LIMITS.MAX_FILE_SIZE) need far more than the 30s used for small media images.
-  BLOSSOM_UPLOAD_TIMEOUT_MS: 3e5
+  BLOSSOM_UPLOAD_TIMEOUT_MS: 3e5,
+  // Ceiling for a single encrypted Blossom blob download (GET). Same budget as upload.
+  BLOSSOM_FETCH_TIMEOUT_MS: 3e5
 };
 var LIMITS = {
   MAX_INPUT_LENGTH: 1e5,
@@ -100,6 +102,12 @@ var LIMITS = {
   // providers may lower it per deployment.
   MAX_FILE_SIZE: 1073741824,
   // 1 GiB
+  // Cap for the ENCRYPTED Blossom path (web/SDK). The encrypt-then-upload flow is
+  // whole-buffer in WebCrypto + BlossomService (~3x file-size peak RAM), so this is
+  // deliberately far below MAX_FILE_SIZE to stay safe in a browser tab; larger files
+  // use iroh. The relay enforces a ~128 MiB server-side backstop.
+  MAX_BLOSSOM_ENCRYPTED_BYTES: 104857600,
+  // 100 MiB
   MAX_TIMEOUT_SECS: 600,
   // Upper bound for execution budgets (`max_execution_secs` / `execution_timeout_secs`).
   // Distinct from MAX_TIMEOUT_SECS (the result-wait cap): execution budgets may be
@@ -1237,6 +1245,62 @@ var BlossomService = class {
       clearTimeout(timer);
     }
   }
+  /**
+   * Download a public blob (BUD-01 GET, no auth). Bounds memory on the ACTUAL streamed bytes (never
+   * the declared Content-Length) and verifies the sha256 when `expectedSha256` is given. Browser-safe.
+   */
+  async download(url, opts = {}) {
+    const maxBytes = opts.maxBytes ?? LIMITS.MAX_FILE_SIZE;
+    const controller = new AbortController();
+    const timer = setTimeout(
+      () => controller.abort(),
+      opts.timeoutMs ?? DEFAULTS.BLOSSOM_FETCH_TIMEOUT_MS
+    );
+    try {
+      const res = await fetch(url, { signal: controller.signal });
+      if (!res.ok) {
+        throw new Error(`Download failed: ${res.status} ${res.statusText}`);
+      }
+      const declared = Number(res.headers.get("content-length"));
+      if (Number.isFinite(declared) && declared > maxBytes) {
+        throw new Error(`Blob too large: ${declared} bytes exceeds limit of ${maxBytes}.`);
+      }
+      if (!res.body) {
+        throw new Error("Download response has no body.");
+      }
+      const reader = res.body.getReader();
+      const chunks = [];
+      let total = 0;
+      let chunk = await reader.read();
+      while (!chunk.done) {
+        total += chunk.value.byteLength;
+        if (total > maxBytes) {
+          await reader.cancel();
+          throw new Error(`Blob exceeds limit of ${maxBytes} bytes.`);
+        }
+        chunks.push(chunk.value);
+        chunk = await reader.read();
+      }
+      const bytes = new Uint8Array(total);
+      let offset = 0;
+      for (const c of chunks) {
+        bytes.set(c, offset);
+        offset += c.byteLength;
+      }
+      if (opts.expectedSha256 !== void 0) {
+        const digest = await crypto.subtle.digest("SHA-256", bytes);
+        const hashHex = [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, "0")).join("");
+        if (hashHex !== opts.expectedSha256) {
+          throw new Error(
+            `Download integrity check failed: got ${hashHex}, expected ${opts.expectedSha256}.`
+          );
+        }
+      }
+      return bytes;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
   async uploadToBlossom(identity, bytes, hashHex, mime) {
     const contentType = mime || "application/octet-stream";
     const authHeader = this.authHeader(identity, "upload", hashHex);
@@ -1952,6 +2016,26 @@ var FileTransportSchema = z.discriminatedUnion("kind", [
     kind: z.literal("iroh"),
     /** Opaque iroh `BlobTicket` string. Parsed into a real ticket only at fetch time. */
     ticket: z.string().min(1).max(MAX_TICKET_LENGTH)
+  }),
+  z.object({
+    kind: z.literal("blossom"),
+    /** Public HTTP(S) URL of the CIPHERTEXT blob on a Blossom relay. */
+    url: z.string().url().max(2048),
+    /** sha256 (lowercase hex) of the ciphertext - what the relay stores and addresses. */
+    sha256: z.string().regex(/^[0-9a-f]{64}$/),
+    /**
+     * Hybrid-encryption parameters. The file bytes are AES-256-GCM encrypted with a random
+     * content key; that key is NIP-44-wrapped to the recipient. `name`/`mime`/`size` on the
+     * attachment describe the PLAINTEXT and live only inside the (encrypted) envelope - never
+     * sent to the relay (the relay only ever sees opaque ciphertext).
+     */
+    enc: z.object({
+      alg: z.literal("AES-256-GCM"),
+      /** base64 12-byte GCM IV (non-secret). */
+      iv: z.string().min(1).max(64),
+      /** NIP-44-wrapped content key. */
+      key: z.string().min(1).max(2048)
+    })
   })
 ]);
 var FileAttachmentSchema = z.object({
@@ -1960,8 +2044,18 @@ var FileAttachmentSchema = z.object({
   /** Declared size in bytes (display/hint only; enforcement is on actual streamed bytes). */
   size: z.number().int().nonnegative(),
   mime: z.string().min(1).max(255),
-  /** Ordered by sender preference; at least one. */
-  transports: z.array(FileTransportSchema).min(1),
+  /**
+   * Ordered by sender preference; at least one KNOWN transport. Parsed leniently: unknown
+   * transport `kind`s are dropped (not rejected) so adding a new transport never makes an older
+   * decoder throw away the whole envelope - it just ignores the kinds it doesn't know and uses
+   * the ones it does. At least one known transport must survive, else the attachment is invalid.
+   */
+  transports: z.array(z.unknown()).transform(
+    (arr) => arr.flatMap((t) => {
+      const parsed = FileTransportSchema.safeParse(t);
+      return parsed.success ? [parsed.data] : [];
+    })
+  ).refine((arr) => arr.length >= 1, { message: "attachment has no known transport" }),
   /** Optional provider hint (unix seconds) for when seeding may stop. */
   seedingExpiresAt: z.number().int().nonnegative().optional()
 });
@@ -1970,6 +2064,37 @@ var JobPayloadEnvelopeSchema = z.object({
   text: z.string().optional(),
   attachment: FileAttachmentSchema.optional()
 });
+var ACCEPT_TRANSPORTS_TAG = "accept";
+var KNOWN_TRANSPORT_KINDS = ["iroh", "blossom"];
+function isKnownTransportKind(value) {
+  return KNOWN_TRANSPORT_KINDS.includes(value);
+}
+function buildAcceptTransportsTag(kinds) {
+  const seen = /* @__PURE__ */ new Set();
+  const out = [ACCEPT_TRANSPORTS_TAG];
+  for (const kind of kinds) {
+    if (isKnownTransportKind(kind) && !seen.has(kind)) {
+      seen.add(kind);
+      out.push(kind);
+    }
+  }
+  return out;
+}
+function readAcceptedTransports(tags) {
+  const tag = tags.find((t) => t[0] === ACCEPT_TRANSPORTS_TAG);
+  if (tag === void 0) {
+    return void 0;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const value of tag.slice(1)) {
+    if (isKnownTransportKind(value) && !seen.has(value)) {
+      seen.add(value);
+      out.push(value);
+    }
+  }
+  return out.length > 0 ? out : void 0;
+}
 function encodeJobPayload(payload) {
   const envelope = { v: ENVELOPE_VERSION };
   if (payload.text !== void 0) {
@@ -2072,6 +2197,12 @@ var MarketplaceService = class {
       tags.push(["p", options.providerPubkey]);
       tags.push(["encrypted", "nip44"]);
     }
+    if (options.acceptTransports && options.acceptTransports.length > 0) {
+      const acceptTag = buildAcceptTransportsTag(options.acceptTransports);
+      if (acceptTag.length > 1) {
+        tags.push(acceptTag);
+      }
+    }
     const kind = jobRequestKind(options.kindOffset ?? DEFAULT_KIND_OFFSET);
     const event = finalizeEvent(
       {
@@ -3480,6 +3611,147 @@ var ElisymClient = class {
   }
 };
 
+// src/primitives/file-crypto.ts
+var KEY_BYTES = 32;
+var IV_BYTES = 12;
+function bytesToBase64(bytes) {
+  let bin = "";
+  for (const b of bytes) {
+    bin += String.fromCharCode(b);
+  }
+  return btoa(bin);
+}
+function base64ToBytes(b64) {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i += 1) {
+    out[i] = bin.charCodeAt(i);
+  }
+  return out;
+}
+async function encryptBytesForRecipient(bytes, senderSk, recipientPubkey) {
+  const rawKey = crypto.getRandomValues(new Uint8Array(KEY_BYTES));
+  const iv = crypto.getRandomValues(new Uint8Array(IV_BYTES));
+  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["encrypt"]);
+  const ct = await crypto.subtle.encrypt({ name: "AES-GCM", iv, tagLength: 128 }, key, bytes);
+  const wrappedKey = nip44Encrypt(bytesToBase64(rawKey), senderSk, recipientPubkey);
+  return { ciphertext: new Uint8Array(ct), wrappedKey, iv: bytesToBase64(iv) };
+}
+async function decryptBytesFromSender(ciphertext, wrappedKey, iv, receiverSk, senderPubkey) {
+  const rawKey = base64ToBytes(nip44Decrypt(wrappedKey, receiverSk, senderPubkey));
+  const key = await crypto.subtle.importKey("raw", rawKey, "AES-GCM", false, ["decrypt"]);
+  const pt = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv: base64ToBytes(iv), tagLength: 128 },
+    key,
+    ciphertext
+  );
+  return new Uint8Array(pt);
+}
+
+// src/transport/blossom-transport.ts
+var AES_GCM_TAG_BYTES = 16;
+function createBlossomTransport(opts) {
+  const { blossom, identity } = opts;
+  return {
+    async seedBytes({ bytes, recipientPubkey }) {
+      if (bytes.byteLength > LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES) {
+        throw new Error(
+          `File too large for encrypted Blossom: ${bytes.byteLength} bytes exceeds ${LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES}.`
+        );
+      }
+      const { ciphertext, wrappedKey, iv } = await encryptBytesForRecipient(
+        bytes,
+        identity.secretKey,
+        recipientPubkey
+      );
+      const blob = new Blob([ciphertext], { type: "application/octet-stream" });
+      const descriptor = await blossom.upload(identity, blob);
+      if (descriptor.provider !== "blossom") {
+        throw new Error("Blossom upload fell back to a non-content-addressed provider.");
+      }
+      return {
+        kind: "blossom",
+        url: descriptor.url,
+        sha256: descriptor.sha256,
+        enc: { alg: "AES-256-GCM", iv, key: wrappedKey }
+      };
+    },
+    async fetchToBytes({ transport, senderPubkey, maxBytes }) {
+      const plaintextCap = maxBytes ?? LIMITS.MAX_BLOSSOM_ENCRYPTED_BYTES;
+      const ciphertext = await blossom.download(transport.url, {
+        maxBytes: plaintextCap + AES_GCM_TAG_BYTES,
+        expectedSha256: transport.sha256
+      });
+      return decryptBytesFromSender(
+        ciphertext,
+        transport.enc.key,
+        transport.enc.iv,
+        identity.secretKey,
+        senderPubkey
+      );
+    }
+  };
+}
+
+// src/transport/file-jobs.ts
+var EXECUTABLE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".exe",
+  ".dll",
+  ".bat",
+  ".cmd",
+  ".com",
+  ".msi",
+  ".sh",
+  ".app",
+  ".scr",
+  ".ps1"
+]);
+var EXECUTABLE_MIMES = /* @__PURE__ */ new Set([
+  "application/x-msdownload",
+  "application/x-msdos-program",
+  "application/x-sh",
+  "application/x-executable",
+  "application/vnd.microsoft.portable-executable",
+  "application/x-mach-binary"
+]);
+function looksExecutable(name, type) {
+  const dot = name.lastIndexOf(".");
+  const ext = dot >= 0 ? name.slice(dot).toLowerCase() : "";
+  return EXECUTABLE_EXTENSIONS.has(ext) || EXECUTABLE_MIMES.has(type);
+}
+async function buildEncryptedFileInput(args) {
+  const { file, providerPubkey, identity, blossom } = args;
+  const name = file.name ?? "upload";
+  if (looksExecutable(name, file.type)) {
+    throw new Error("Refusing to upload an executable file.");
+  }
+  const transport = createBlossomTransport({ blossom, identity });
+  const bytes = new Uint8Array(await file.arrayBuffer());
+  const member = await transport.seedBytes({ bytes, recipientPubkey: providerPubkey });
+  return {
+    name,
+    size: bytes.byteLength,
+    mime: file.type || "application/octet-stream",
+    transports: [member]
+  };
+}
+async function fetchEncryptedFileOutput(args) {
+  const { attachment, providerPubkey, identity, blossom, maxBytes } = args;
+  const member = attachment.transports.find(
+    (t) => t.kind === "blossom"
+  );
+  if (member === void 0) {
+    throw new Error("Attachment has no blossom transport.");
+  }
+  const transport = createBlossomTransport({ blossom, identity });
+  const bytes = await transport.fetchToBytes({
+    transport: member,
+    senderPubkey: providerPubkey,
+    maxBytes
+  });
+  return { bytes, name: attachment.name, mime: attachment.mime };
+}
+
 // src/services/jobErrors.ts
 var AGENT_UNAVAILABLE_MARKERS = [
   "agent temporarily unavailable",
@@ -4051,6 +4323,6 @@ function makeCensor() {
   };
 }
 
-export { BlossomService, BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, DiscoveryService, ELISYM_PROTOCOL_TAG, ENVELOPE_VERSION, ElisymClient, ElisymIdentity, GlobalConfigSchema, INPUT_REDACT_PATHS, JobWaitTimeoutError, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_LONG_FORM_ARTICLE, KIND_PING, KIND_PONG, KNOWN_ASSETS, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, NATIVE_SOL, NostrPool, POLICY_D_TAG_PREFIX, POLICY_TYPE_REGEX, POLICY_T_TAG, PROTOCOL_PROGRAM_ID_DEVNET, PaymentRequestSchema, PingService, PoliciesService, RELAYS, SECRET_REDACT_PATHS, SessionSpendLimitEntrySchema, SolanaPaymentStrategy, USDC_SOLANA_DEVNET, aggregateNetworkStats, assertExpiry, assertLamports, assetByKey, assetKey, buildPaymentInstructions, calculateProtocolFee, classifyJobError, clearPriorityFeeCache, clearProtocolConfigCache, clearQuickVerifyCache, compareAgentsByRank, computeRankKey, createPaymentRequestWithOnchainConfig, createSlidingWindowLimiter, decodeJobPayload, encodeJobPayload, estimateNetworkBaseline, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, formatAssetAmount, formatFeeBreakdown, formatNetworkBaseline, formatSol, getNetworkStats, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parseAssetAmount, parsePaymentRequest, pickPercentileFee, resolveAssetFromPaymentRequest, resolveKnownAsset, timeAgo, toDTag, truncateKey, utf8ByteLength, validateAgentName, validateExpiry, verifyJobPaymentQuick };
+export { ACCEPT_TRANSPORTS_TAG, BlossomService, BoundedSet, DEFAULTS, DEFAULT_KIND_OFFSET, DEFAULT_REDACT_PATHS, DiscoveryService, ELISYM_PROTOCOL_TAG, ENVELOPE_VERSION, ElisymClient, ElisymIdentity, GlobalConfigSchema, INPUT_REDACT_PATHS, JobWaitTimeoutError, KIND_APP_HANDLER, KIND_JOB_FEEDBACK, KIND_JOB_REQUEST, KIND_JOB_REQUEST_BASE, KIND_JOB_RESULT, KIND_JOB_RESULT_BASE, KIND_LONG_FORM_ARTICLE, KIND_PING, KIND_PONG, KNOWN_ASSETS, LAMPORTS_PER_SOL, LIMITS, MarketplaceService, MediaService, NATIVE_SOL, NostrPool, POLICY_D_TAG_PREFIX, POLICY_TYPE_REGEX, POLICY_T_TAG, PROTOCOL_PROGRAM_ID_DEVNET, PaymentRequestSchema, PingService, PoliciesService, RELAYS, SECRET_REDACT_PATHS, SessionSpendLimitEntrySchema, SolanaPaymentStrategy, USDC_SOLANA_DEVNET, aggregateNetworkStats, assertExpiry, assertLamports, assetByKey, assetKey, buildAcceptTransportsTag, buildEncryptedFileInput, buildPaymentInstructions, calculateProtocolFee, classifyJobError, clearPriorityFeeCache, clearProtocolConfigCache, clearQuickVerifyCache, compareAgentsByRank, computeRankKey, createBlossomTransport, createPaymentRequestWithOnchainConfig, createSlidingWindowLimiter, decodeJobPayload, decryptBytesFromSender, encodeJobPayload, encryptBytesForRecipient, estimateNetworkBaseline, estimatePriorityFeeMicroLamports, estimateSolFeeLamports, fetchEncryptedFileOutput, formatAssetAmount, formatFeeBreakdown, formatNetworkBaseline, formatSol, getNetworkStats, getProtocolConfig, getProtocolProgramId, jobRequestKind, jobResultKind, makeCensor, nip44Decrypt, nip44Encrypt, parseAssetAmount, parsePaymentRequest, pickPercentileFee, readAcceptedTransports, resolveAssetFromPaymentRequest, resolveKnownAsset, timeAgo, toDTag, truncateKey, utf8ByteLength, validateAgentName, validateExpiry, verifyJobPaymentQuick };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map