@toon-protocol/core 3.2.1 → 3.4.0

package/dist/wire/index.js

@@ -0,0 +1,115 @@
+import {
+  EnvelopeError,
+  EnvelopeErrorKind,
+  GIFTWRAP_NONCE_LENGTH,
+  GIFTWRAP_PUBLIC_KEY_LENGTH,
+  GIFTWRAP_SECRET_LENGTH,
+  GIFTWRAP_TYPE_REQUEST,
+  GIFTWRAP_TYPE_RESPONSE,
+  GiftWrapError,
+  GiftWrapErrorKind,
+  OerError,
+  OerErrorKind,
+  SealedResponseError,
+  decodeEnvelope,
+  decodeEnvelopeRequest,
+  decodeEnvelopeResponse,
+  decodeVarOctetString,
+  decodeVarUint,
+  deriveCondition,
+  deriveFulfillment,
+  encodeEnvelope,
+  encodeEnvelopeRequest,
+  encodeEnvelopeResponse,
+  encodeVarOctetString,
+  encodeVarUint,
+  envelopeHeader,
+  giftWrapPublicKey,
+  localGiftWrapEcdh,
+  looksLikeSealedResponse,
+  openRequest,
+  openResponse,
+  readExchangeOutcome,
+  sealExchange,
+  sealRequest,
+  sealRequestWithRandomness,
+  sealResponse,
+  sealResponseWithRandomness
+} from "../chunk-K72H36Y4.js";
+
+// src/wire/condition.ts
+import { sha256 } from "@noble/hashes/sha2.js";
+import { randomBytes } from "@noble/hashes/utils.js";
+var CONDITION_LENGTH = 32;
+function mintExecutionCondition() {
+  const preimage = randomBytes(CONDITION_LENGTH);
+  return { preimage, condition: sha256(preimage) };
+}
+function isZeroCondition(condition) {
+  if (condition === void 0) return true;
+  for (const byte of condition) {
+    if (byte !== 0) return false;
+  }
+  return true;
+}
+function assertValidCondition(condition) {
+  if (condition.length !== CONDITION_LENGTH) {
+    throw new Error(
+      `executionCondition must be exactly ${CONDITION_LENGTH} bytes, got ${condition.length}`
+    );
+  }
+}
+function fulfillmentMatchesCondition(fulfillment, condition) {
+  if (fulfillment === void 0 || fulfillment.length !== CONDITION_LENGTH) {
+    return false;
+  }
+  const digest = sha256(fulfillment);
+  for (let i = 0; i < CONDITION_LENGTH; i++) {
+    if (digest[i] !== condition[i]) return false;
+  }
+  return true;
+}
+export {
+  CONDITION_LENGTH,
+  EnvelopeError,
+  EnvelopeErrorKind,
+  GIFTWRAP_NONCE_LENGTH,
+  GIFTWRAP_PUBLIC_KEY_LENGTH,
+  GIFTWRAP_SECRET_LENGTH,
+  GIFTWRAP_TYPE_REQUEST,
+  GIFTWRAP_TYPE_RESPONSE,
+  GiftWrapError,
+  GiftWrapErrorKind,
+  OerError,
+  OerErrorKind,
+  SealedResponseError,
+  assertValidCondition,
+  decodeEnvelope,
+  decodeEnvelopeRequest,
+  decodeEnvelopeResponse,
+  decodeVarOctetString,
+  decodeVarUint,
+  deriveCondition,
+  deriveFulfillment,
+  encodeEnvelope,
+  encodeEnvelopeRequest,
+  encodeEnvelopeResponse,
+  encodeVarOctetString,
+  encodeVarUint,
+  envelopeHeader,
+  fulfillmentMatchesCondition,
+  giftWrapPublicKey,
+  isZeroCondition,
+  localGiftWrapEcdh,
+  looksLikeSealedResponse,
+  mintExecutionCondition,
+  openRequest,
+  openResponse,
+  readExchangeOutcome,
+  sealExchange,
+  sealRequest,
+  sealRequestWithRandomness,
+  sealResponse,
+  sealResponseWithRandomness
+};
+//# sourceMappingURL=index.js.map

package/dist/wire/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wire/condition.ts"],"sourcesContent":["/**\n * Sender-chosen ILP execution conditions (toon-client#350, rolling-swap\n * prerequisite — toon-meta#145 §3 R1/R2).\n *\n * Contract (normative: connector `docs/local-delivery-fulfillment-contract.md`,\n * connector#309):\n *   - An ABSENT or ALL-ZERO (32×0x00) `executionCondition` is the LEGACY\n *     class: no hashlock, no verification — today's publish/upload writes.\n *   - Any NON-ZERO condition is SENDER-CHOSEN: the sender mints a fresh\n *     random 32-byte preimage `P` per packet, sets `C = sha256(P)` on the\n *     PREPARE, and on FULFILL MUST verify that the returned fulfillment\n *     hashes back to `C` — a missing/malformed/mismatching fulfillment is a\n *     hard failure (the packet is counted failed, never silently accepted).\n *\n * Isomorphic: @noble/hashes only (no Buffer, no node:crypto).\n */\n\nimport { sha256 } from '@noble/hashes/sha2.js';\nimport { randomBytes } from '@noble/hashes/utils.js';\n\n/** Exact byte length of an ILP execution condition / fulfillment preimage. */\nexport const CONDITION_LENGTH = 32;\n\n/** A freshly minted per-packet hashlock: `condition = sha256(preimage)`. */\nexport interface ExecutionConditionPair {\n  /** Random 32-byte preimage `P` — reveal is the commit act; never reuse. */\n  preimage: Uint8Array;\n  /** `C = sha256(P)` — goes on the PREPARE's `executionCondition`. */\n  condition: Uint8Array;\n}\n\n/**\n * Mint a fresh random 32-byte preimage and its sha256 condition (spec R1).\n * Mint one PER PACKET: a reused preimage lets any observer of packet *i*\n * fulfill packet *i+1* without the sender's consent.\n */\nexport function mintExecutionCondition(): ExecutionConditionPair {\n  const preimage = randomBytes(CONDITION_LENGTH);\n  return { preimage, condition: sha256(preimage) };\n}\n\n/**\n * True when `condition` selects the LEGACY (unverified) class: absent or\n * all-zero. The OER wire treats absent and 32×0x00 identically.\n */\nexport function isZeroCondition(condition: Uint8Array | undefined): boolean {\n  if (condition === undefined) return true;\n  for (const byte of condition) {\n    if (byte !== 0) return false;\n  }\n  return true;\n}\n\n/**\n * Validate a caller-supplied execution condition before it goes on the wire.\n * @throws {Error} When the condition is not exactly 32 bytes — the OER\n *   serializer would otherwise silently zero-fill it, downgrading a\n *   sender-chosen packet to the legacy unverified class.\n */\nexport function assertValidCondition(condition: Uint8Array): void {\n  if (condition.length !== CONDITION_LENGTH) {\n    throw new Error(\n      `executionCondition must be exactly ${CONDITION_LENGTH} bytes, got ${condition.length}`\n    );\n  }\n}\n\n/**\n * True iff `fulfillment` is exactly 32 bytes and `sha256(fulfillment)`\n * equals `condition` — the sender-side FULFILL check (spec R6's mirror).\n * Fail-closed: an undefined/short/long fulfillment never matches.\n */\nexport function fulfillmentMatchesCondition(\n  fulfillment: Uint8Array | undefined,\n  condition: Uint8Array\n): boolean {\n  if (fulfillment === undefined || fulfillment.length !== CONDITION_LENGTH) {\n    return false;\n  }\n  const digest = sha256(fulfillment);\n  // Plain comparison is fine: both operands are locally computed/received\n  // values on the sender; there is no secret to protect from timing here.\n  for (let i = 0; i < CONDITION_LENGTH; i++) {\n    if (digest[i] !== condition[i]) return false;\n  }\n  return true;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiBA,SAAS,cAAc;AACvB,SAAS,mBAAmB;AAGrB,IAAM,mBAAmB;AAezB,SAAS,yBAAiD;AAC/D,QAAM,WAAW,YAAY,gBAAgB;AAC7C,SAAO,EAAE,UAAU,WAAW,OAAO,QAAQ,EAAE;AACjD;AAMO,SAAS,gBAAgB,WAA4C;AAC1E,MAAI,cAAc,OAAW,QAAO;AACpC,aAAW,QAAQ,WAAW;AAC5B,QAAI,SAAS,EAAG,QAAO;AAAA,EACzB;AACA,SAAO;AACT;AAQO,SAAS,qBAAqB,WAA6B;AAChE,MAAI,UAAU,WAAW,kBAAkB;AACzC,UAAM,IAAI;AAAA,MACR,sCAAsC,gBAAgB,eAAe,UAAU,MAAM;AAAA,IACvF;AAAA,EACF;AACF;AAOO,SAAS,4BACd,aACA,WACS;AACT,MAAI,gBAAgB,UAAa,YAAY,WAAW,kBAAkB;AACxE,WAAO;AAAA,EACT;AACA,QAAM,SAAS,OAAO,WAAW;AAGjC,WAAS,IAAI,GAAG,IAAI,kBAAkB,KAAK;AACzC,QAAI,OAAO,CAAC,MAAM,UAAU,CAAC,EAAG,QAAO;AAAA,EACzC;AACA,SAAO;AACT;","names":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toon-protocol/core",
-  "version": "3.2.1",
+  "version": "3.4.0",
   "description": "Core library for Nostr-based ILP peer discovery and settlement",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,10 @@
     "./toon": {
       "types": "./dist/toon/index.d.ts",
       "import": "./dist/toon/index.js"
+    },
+    "./wire": {
+      "types": "./dist/wire/index.d.ts",
+      "import": "./dist/wire/index.js"
     }
   },
   "files": [
@@ -44,6 +48,8 @@
   },
   "dependencies": {
     "@ardrive/turbo-sdk": "^1.21.0",
+    "@noble/ciphers": "^2.0.0",
+    "@noble/curves": "^2.0.0",
     "@noble/hashes": "^2.0.0",
     "@scure/bip32": "^2.0.0",
     "@scure/bip39": "^2.0.0",