kawasekit 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -532,6 +532,12 @@ var PolicyGatedSignerConfigError = class extends Error {
     this.reason = reason;
   }
 };
+var CoSignUnavailableError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CoSignUnavailableError";
+  }
+};
 
 // src/signer/gate.ts
 function requireNonBypassable(signer) {
@@ -576,11 +582,11 @@ var X402PolicyRejectedError = class extends Error {
   reason;
   /** The full typed rejection (its `detail` never contains the nonce or signature). */
   rejection;
-  constructor(rejection, options) {
-    super(`x402 payment rejected by policy: ${rejection.reason} (${rejection.detail})`, options);
+  constructor(rejection2, options) {
+    super(`x402 payment rejected by policy: ${rejection2.reason} (${rejection2.detail})`, options);
     this.name = "X402PolicyRejectedError";
-    this.reason = rejection.reason;
-    this.rejection = rejection;
+    this.reason = rejection2.reason;
+    this.rejection = rejection2;
   }
 };
 var KNOWN_ASSETS = [
@@ -829,6 +835,213 @@ function createLocalPolicyGatedSigner(params) {
   };
 }
 
+// src/signer/mpc-2p-wire.ts
+var WIRE_VERSION = 1;
+function toWireIntent(intent) {
+  return {
+    token: intent.token.toLowerCase(),
+    chain_id: intent.chainId,
+    from: intent.from.toLowerCase(),
+    to: intent.to.toLowerCase(),
+    value: intent.value.toString(),
+    valid_after: intent.validAfter.toString(),
+    valid_before: intent.validBefore.toString(),
+    nonce: intent.nonce.toLowerCase()
+  };
+}
+function canonicalIntentBytes(intent) {
+  const lines = [
+    "kawasekit-mpc-2p/cosign-request/v2",
+    `token=${intent.token.toLowerCase()}`,
+    `chainId=${intent.chainId}`,
+    `from=${intent.from.toLowerCase()}`,
+    `to=${intent.to.toLowerCase()}`,
+    `value=${intent.value}`,
+    `validAfter=${intent.validAfter}`,
+    `validBefore=${intent.validBefore}`,
+    `nonce=${intent.nonce.toLowerCase()}`
+  ];
+  return new TextEncoder().encode(lines.map((l) => `${l}
+`).join(""));
+}
+
+// src/signer/mpc-2p.ts
+var POLICY_REASONS = /* @__PURE__ */ new Set([
+  "revoked",
+  "expired",
+  "token_not_allowed",
+  "recipient_not_allowed",
+  "amount_exceeds_per_sign",
+  "amount_exceeds_cumulative",
+  "intent_digest_mismatch",
+  "unauthenticated",
+  "from_mismatch",
+  "nonce_reuse_conflict"
+]);
+function rejection(reason, detail) {
+  return { ok: false, rejection: { reason, detail } };
+}
+function createMpc2pPolicyGatedSigner(params) {
+  const { agent, transport, authenticator, session } = params;
+  const pinned = resolveAssetParam(params.asset);
+  const from = viem.getAddress(params.from);
+  const agentEoa = viem.getAddress(agent.groupEoa());
+  if (agentEoa !== from) {
+    throw new PolicyGatedSignerConfigError(
+      "from",
+      `the agent share controls ${agentEoa} but params.from is ${from}`
+    );
+  }
+  return {
+    enforcement: "cryptographic",
+    from,
+    async sign(intent) {
+      if (viem.getAddress(intent.from) !== from) {
+        return rejection(
+          "from_mismatch",
+          `intent.from ${viem.getAddress(intent.from)} does not equal signer.from ${from}`
+        );
+      }
+      if (viem.getAddress(intent.token) !== pinned.verifyingContract) {
+        return rejection(
+          "token_not_allowed",
+          `intent.token ${viem.getAddress(intent.token)} does not equal the signer's pinned verifyingContract ${pinned.verifyingContract}`
+        );
+      }
+      const digest = viem.hashTypedData({
+        domain: resolvedAssetToEip3009Domain(pinned, intent.chainId),
+        types: transferWithAuthorizationTypes,
+        primaryType: "TransferWithAuthorization",
+        message: {
+          from,
+          to: intent.to,
+          value: intent.value,
+          validAfter: intent.validAfter,
+          validBefore: intent.validBefore,
+          nonce: intent.nonce
+        }
+      });
+      const authTag = await authenticator.tag(canonicalIntentBytes(intent));
+      const conn = await openConnection(transport);
+      try {
+        return await runCeremony(conn, agent, session.id, intent, digest, authTag);
+      } finally {
+        try {
+          await conn.close();
+        } catch {
+        }
+      }
+    },
+    describe() {
+      return {
+        enforcement: "cryptographic",
+        from,
+        policyId: session.id,
+        notAfter: session.notAfter,
+        // The backend owns authoritative revocation (a revoked session → a
+        // rejection at sign time); this metadata field is best-effort.
+        revoked: false
+      };
+    }
+  };
+}
+async function openConnection(transport) {
+  try {
+    return await transport.connect();
+  } catch (cause) {
+    throw new CoSignUnavailableError("co-signer connection failed", { cause });
+  }
+}
+async function runCeremony(conn, agent, sessionId, intent, digest, authTag) {
+  const send = async (frame) => {
+    try {
+      await conn.send(frame);
+    } catch (cause) {
+      throw new CoSignUnavailableError("co-sign connection dropped while sending", { cause });
+    }
+  };
+  const recv = async () => {
+    let frame;
+    try {
+      frame = await conn.recv();
+    } catch (cause) {
+      throw new CoSignUnavailableError("co-sign connection dropped mid-ceremony", { cause });
+    }
+    if (frame.wire_version !== WIRE_VERSION) {
+      throw new CoSignUnavailableError(
+        `co-signer spoke wire_version ${frame.wire_version}, expected ${WIRE_VERSION}`
+      );
+    }
+    return frame;
+  };
+  await send({
+    wire_version: WIRE_VERSION,
+    kind: "request",
+    session_id: sessionId,
+    intent: toWireIntent(intent),
+    auth_tag: authTag
+  });
+  let first;
+  try {
+    first = agent.start(digest);
+  } catch (cause) {
+    throw new CoSignUnavailableError("the agent failed to start the ceremony", { cause });
+  }
+  await send({ wire_version: WIRE_VERSION, kind: "round", payload: first });
+  let agentSig = null;
+  for (; ; ) {
+    const frame = await recv();
+    switch (frame.kind) {
+      case "round": {
+        let step;
+        try {
+          step = agent.step(frame.payload);
+        } catch (cause) {
+          throw new CoSignUnavailableError("the agent rejected a round frame", { cause });
+        }
+        if ("outbound" in step) {
+          await send({ wire_version: WIRE_VERSION, kind: "round", payload: step.outbound });
+        } else {
+          agentSig = step.signature;
+        }
+        break;
+      }
+      case "result": {
+        if (agentSig === null) {
+          throw new CoSignUnavailableError(
+            "the backend returned a result before the agent derived a signature"
+          );
+        }
+        if (frame.r.toLowerCase() !== agentSig.r.toLowerCase() || frame.s.toLowerCase() !== agentSig.s.toLowerCase() || frame.v !== agentSig.v) {
+          throw new CoSignUnavailableError("the backend and agent derived different signatures");
+        }
+        return { ok: true, signature: assembleSignature(agentSig), intent };
+      }
+      case "rejection": {
+        if (POLICY_REASONS.has(frame.reason)) {
+          return rejection(frame.reason, frame.detail);
+        }
+        throw new CoSignUnavailableError(
+          `co-signer returned a non-policy rejection (${frame.reason}): ${frame.detail}`
+        );
+      }
+      case "error": {
+        throw new CoSignUnavailableError(`co-signer error: ${frame.message}`);
+      }
+      default: {
+        throw new CoSignUnavailableError("co-signer sent an unexpected frame");
+      }
+    }
+  }
+}
+function assembleSignature(sig) {
+  const yParity = sig.v - 27;
+  if (yParity !== 0 && yParity !== 1) {
+    throw new CoSignUnavailableError(`malformed recovery id v=${sig.v} (expected 27 or 28)`);
+  }
+  return viem.serializeSignature({ r: sig.r, s: sig.s, yParity });
+}
+
 // src/x402/types.ts
 var X402_VERSION = 2;
 var EIP155_PREFIX = "eip155:";
@@ -2825,6 +3038,7 @@ async function rotateSessionKey(params) {
 }
 
 exports.ChainNotSupportedError = ChainNotSupportedError;
+exports.CoSignUnavailableError = CoSignUnavailableError;
 exports.IdempotencyConfigError = IdempotencyConfigError;
 exports.IdempotencyRecordParseError = IdempotencyRecordParseError;
 exports.IdempotencyRecordVersionError = IdempotencyRecordVersionError;
@@ -2842,6 +3056,7 @@ exports.SessionEnvelopeSignerMismatchError = SessionEnvelopeSignerMismatchError;
 exports.SessionEnvelopeVersionError = SessionEnvelopeVersionError;
 exports.SpendingPolicyConfigError = SpendingPolicyConfigError;
 exports.TransferJpycInputError = TransferJpycInputError;
+exports.WIRE_VERSION = WIRE_VERSION;
 exports.X402InvalidConfigError = X402InvalidConfigError;
 exports.X402InvalidPayloadError = X402InvalidPayloadError;
 exports.X402PolicyRejectedError = X402PolicyRejectedError;
@@ -2860,6 +3075,7 @@ exports.avalancheFuji = avalancheFuji;
 exports.buildPaymentRequiredResponse = buildPaymentRequiredResponse;
 exports.buildPaymentRequirements = buildPaymentRequirements;
 exports.cancelAuthorizationTypes = cancelAuthorizationTypes;
+exports.canonicalIntentBytes = canonicalIntentBytes;
 exports.chainIdToX402Network = chainIdToX402Network;
 exports.createAgentSmartAccount = createAgentSmartAccount;
 exports.createCoinbaseFacilitator = createCoinbaseFacilitator;
@@ -2868,6 +3084,7 @@ exports.createIdempotencyKeyBuilder = createIdempotencyKeyBuilder;
 exports.createInMemoryIdempotencyStore = createInMemoryIdempotencyStore;
 exports.createJpycDailyLimitPolicies = createJpycDailyLimitPolicies;
 exports.createLocalPolicyGatedSigner = createLocalPolicyGatedSigner;
+exports.createMpc2pPolicyGatedSigner = createMpc2pPolicyGatedSigner;
 exports.createSelfFacilitator = createSelfFacilitator;
 exports.createSpendingPolicy = createSpendingPolicy;
 exports.createX402Handler = createX402Handler;
@@ -2916,6 +3133,7 @@ exports.signCancelAuthorization = signCancelAuthorization;
 exports.signReceiveWithAuthorization = signReceiveWithAuthorization;
 exports.signTransferWithAuthorization = signTransferWithAuthorization;
 exports.supportedChains = supportedChains;
+exports.toWireIntent = toWireIntent;
 exports.transferJpyc = transferJpyc;
 exports.transferWithAuthorizationTypes = transferWithAuthorizationTypes;
 exports.wrapFetch = wrapFetch;