@aastar/sdk 0.25.0 → 0.26.0

package/dist/{chunk-6IZASQSB.cjs → chunk-UZE7IPOK.cjs}

@@ -4201,6 +4201,9 @@ function hexToBytes4(hex) {
   if (clean.length % 2 !== 0) {
     throw new Error("hexToBytes: odd-length hex string");
   }
+  if (clean.length > 0 && !/^[0-9a-fA-F]+$/.test(clean)) {
+    throw new Error("hexToBytes: non-hex characters in input");
+  }
   const out = new Uint8Array(clean.length / 2);
   for (let i = 0; i < out.length; i++) {
     out[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
@@ -4235,11 +4238,14 @@ function buildClientDataJSON(challenge, origin = DEFAULT_ORIGIN) {
   return new TextEncoder().encode(json);
 }
 function buildAuthenticatorData(rpId = DEFAULT_RP_ID, signCount = 1) {
+  if (!Number.isInteger(signCount) || signCount < 0 || signCount > 4294967295) {
+    throw new Error(`buildAuthenticatorData: signCount must be a uint32 (0..2^32-1), got ${signCount}`);
+  }
   const rpIdHash = crypto.createHash("sha256").update(rpId).digest();
   const out = new Uint8Array(37);
   out.set(rpIdHash, 0);
   out[32] = 5;
-  new DataView(out.buffer).setUint32(33, signCount >>> 0, false);
+  new DataView(out.buffer).setUint32(33, signCount, false);
   return out;
 }
 async function buildAuthenticationCredential(opts) {
@@ -4267,6 +4273,9 @@ async function buildAuthenticationCredential(opts) {
 function commitChallenge(nonceBase64Url, payload) {
   const nonce = base64UrlDecode(nonceBase64Url);
   const payloadBytes = typeof payload === "string" ? hexToBytes4(payload) : payload;
+  if (payloadBytes.length !== 32) {
+    throw new Error(`commitChallenge: payload must be a 32-byte digest, got ${payloadBytes.length} bytes`);
+  }
   const committed = crypto.createHash("sha256").update(nonce).update(payloadBytes).digest();
   return base64UrlEncode(new Uint8Array(committed));
 }
@@ -4284,10 +4293,19 @@ async function runWebAuthnCeremony(begin, options) {
     signer: options.signer,
     rpId: options.rpId,
     origin: options.origin,
-    signCount: options.signCount
+    // The KMS enforces a strictly-increasing authenticator signCount (anti-clone). A
+    // server-held signer (P256PasskeySigner) has no native counter, so default to a
+    // monotonic value — else a second signature on the same key fails
+    // "signCount not incremented". A real device passkey passes its own counter.
+    signCount: options.signCount ?? nextSignCount()
   });
   return { ChallengeId: begun.ChallengeId, Credential: credential };
 }
+var _signCountCounter = Math.floor(Date.now() / 1e3);
+function nextSignCount() {
+  _signCountCounter = _signCountCounter + 1 >>> 0;
+  return _signCountCounter;
+}
 function beginAuthenticationChallenge(http2, keyId) {
   return http2.post("/BeginAuthentication", { KeyId: keyId });
 }
@@ -4310,6 +4328,133 @@ function runGrantSessionCeremony(http2, keyId, signer, options) {
 }
 
 // ../airaccount/src/server/services/kms-signer.ts
+function eip712Digest(params) {
+  const types = Object.fromEntries(
+    params.types.filter((t) => t.name !== "EIP712Domain").map((t) => [t.name, t.fields])
+  );
+  const message = Object.fromEntries(params.message.map((f) => [f.name, f.value]));
+  return viem.hashTypedData({
+    domain: params.domain,
+    types,
+    primaryType: params.primaryType,
+    message
+  });
+}
+function u256(x) {
+  if (typeof x === "number" && !Number.isSafeInteger(x)) {
+    throw new Error(`u256: number ${x} exceeds safe-integer range \u2014 pass a bigint or string`);
+  }
+  return BigInt(x);
+}
+var MINT_TAGS = { agent: "AA-AGENT-MINT-v1", p256: "AA-P256-SESSION-MINT-v1" };
+function mintDigest(p) {
+  const hex = p.walletId.replace(/-/g, "");
+  if (hex.length !== 32 || !/^[0-9a-fA-F]+$/.test(hex)) {
+    throw new Error("mintDigest: walletId must be a 16-byte UUID");
+  }
+  if (!Number.isInteger(p.index) || p.index < 0 || p.index > 4294967295) {
+    throw new Error(`mintDigest: index must be a uint32, got ${p.index}`);
+  }
+  if (typeof p.ttlSecs === "number" && !Number.isInteger(p.ttlSecs)) {
+    throw new Error(`mintDigest: ttlSecs must be an integer, got ${p.ttlSecs}`);
+  }
+  const ttlBig = BigInt(p.ttlSecs);
+  if (ttlBig < -(1n << 63n) || ttlBig > (1n << 63n) - 1n) {
+    throw new Error(`mintDigest: ttlSecs out of int64 range: ${ttlBig}`);
+  }
+  const sha2562 = (b) => new Uint8Array(crypto.createHash("sha256").update(b).digest());
+  const utf8 = (s) => new TextEncoder().encode(s);
+  const walletBytes = new Uint8Array(16);
+  for (let i = 0; i < 16; i++) walletBytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  const idx = new Uint8Array(4);
+  new DataView(idx.buffer).setUint32(0, p.index, false);
+  const ttl = new Uint8Array(8);
+  new DataView(ttl.buffer).setBigInt64(0, ttlBig, false);
+  const parts = [utf8(MINT_TAGS[p.kind]), walletBytes, idx, ttl, sha2562(utf8(p.subject))];
+  const total = parts.reduce((n, a) => n + a.length, 0);
+  const buf = new Uint8Array(total);
+  let off = 0;
+  for (const a of parts) {
+    buf.set(a, off);
+    off += a.length;
+  }
+  return "0x" + Buffer.from(sha2562(buf)).toString("hex");
+}
+function grantSessionFinalHash(p) {
+  const callTargetsHash = viem.keccak256(viem.encodePacked(["address[]"], [p.callTargets]));
+  const selectorsHash = viem.keccak256(viem.encodePacked(["bytes4[]"], [p.selectorAllowlist]));
+  const isP256 = "keyX" in p;
+  const inner = isP256 ? viem.keccak256(
+    viem.encodeAbiParameters(
+      [
+        { type: "string" },
+        { type: "uint256" },
+        { type: "address" },
+        { type: "address" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint48" },
+        { type: "address" },
+        { type: "bytes4" },
+        { type: "uint16" },
+        { type: "uint32" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint256" }
+      ],
+      [
+        "GRANT_P256_SESSION_V2",
+        u256(p.chainId),
+        p.verifyingContract,
+        p.account,
+        p.keyX,
+        p.keyY,
+        p.expiry,
+        p.contractScope,
+        p.selectorScope,
+        p.velocityLimit,
+        p.velocityWindow,
+        callTargetsHash,
+        selectorsHash,
+        u256(p.nonce)
+      ]
+    )
+  ) : viem.keccak256(
+    viem.encodeAbiParameters(
+      [
+        { type: "string" },
+        { type: "uint256" },
+        { type: "address" },
+        { type: "address" },
+        { type: "address" },
+        { type: "uint48" },
+        { type: "address" },
+        { type: "bytes4" },
+        { type: "uint16" },
+        { type: "uint32" },
+        { type: "bytes32" },
+        { type: "bytes32" },
+        { type: "uint256" }
+      ],
+      [
+        "GRANT_SESSION_V2",
+        u256(p.chainId),
+        p.verifyingContract,
+        p.account,
+        p.sessionKey,
+        p.expiry,
+        p.contractScope,
+        p.selectorScope,
+        p.velocityLimit,
+        p.velocityWindow,
+        callTargetsHash,
+        selectorsHash,
+        u256(p.nonce)
+      ]
+    )
+  );
+  return viem.hashMessage({ raw: inner });
+}
 var KmsManager = class {
   client;
   logger;
@@ -4399,6 +4544,29 @@ var KmsManager = class {
     this.ensureEnabled();
     return this.amzPost("/ChangePasskey", "TrentService.ChangePasskey", params);
   }
+  // ── Ceremony wrappers for non-signing passkey ops (strict-readiness #135 item 2) ──
+  // These are NON-signing ops, so the challenge is the raw nonce (no payload commitment),
+  // but they MUST go through the ceremony (clientDataJSON present) — strict mode hard-rejects
+  // any assertion without clientDataJSON. Run the ceremony internally so callers never reach
+  // for the deprecated legacy `Passkey` field.
+  /** Schedule key deletion, running the WebAuthn ceremony internally (raw-nonce). */
+  async deleteKeyWithCeremony(params, signer, options) {
+    this.ensureEnabled();
+    const WebAuthn = await this.runAuthenticationCeremony(params.KeyId, signer, options);
+    return this.deleteKey({ ...params, WebAuthn });
+  }
+  /** Unfreeze a dormant key, running the WebAuthn ceremony internally (raw-nonce). */
+  async unfreezeKeyWithCeremony(params, signer, options) {
+    this.ensureEnabled();
+    const WebAuthn = await this.runAuthenticationCeremony(params.KeyId, signer, options);
+    return this.unfreezeKey({ ...params, WebAuthn });
+  }
+  /** Rotate the bound passkey, running the WebAuthn ceremony internally (raw-nonce). */
+  async changePasskeyWithCeremony(params, signer, options) {
+    this.ensureEnabled();
+    const WebAuthn = await this.runAuthenticationCeremony(params.KeyId, signer, options);
+    return this.changePasskey({ ...params, WebAuthn });
+  }
   /**
    * Sign a message or an EIP-155 transaction (WebAuthn-gated).
    * Provide exactly one of `Message` (hex) or `Transaction`. For a raw 32-byte
@@ -4540,24 +4708,50 @@ var KmsManager = class {
     return this.deriveAddress({ ...params, WebAuthn });
   }
   /**
-   * Sign a message or EIP-155 transaction, running the challenge-binding ceremony
-   * internally. `params.KeyId` is required (it identifies the wallet to challenge).
+   * Sign a message or EIP-155 transaction via `/Sign`, running the ceremony internally.
+   * `params.KeyId` is required.
+   *
+   * ⚠️ STRICT MODE: unlike {@link signHashWithCeremony} / {@link signTypedDataWithCeremony},
+   * this does NOT auto-bind a payload commitment, because the TA derives the signed digest
+   * from `Message` / `Transaction` host-side (EIP-191 / RLP) and the SDK can't reproduce it
+   * byte-exactly for every input. So it sends the RAW nonce by default — which the KMS will
+   * REJECT once strict mode (#63) is on. For strict-safe signing either:
+   *   - pass `options.payload` = the exact digest the TA will sign (you computed it), or
+   *   - prefer {@link signHashWithCeremony} (commits to a known 32-byte hash).
    */
   async signWithCeremony(params, signer, options) {
     this.ensureEnabled();
     const WebAuthn = await this.runAuthenticationCeremony(params.KeyId, signer, options);
     return this.sign({ ...params, WebAuthn });
   }
-  /** Sign a 32-byte digest, running the challenge-binding ceremony internally. */
+  /**
+   * Sign a 32-byte digest, running the challenge-binding ceremony internally.
+   * Binds the challenge to `hash` (WYSIWYS commitment, #68) by default — pass an
+   * explicit `options.payload` only to override.
+   */
   async signHashWithCeremony(hash, target, signer, options) {
     this.ensureEnabled();
-    const assertion = await this.runAuthenticationCeremony(target.KeyId, signer, options);
+    const assertion = await this.runAuthenticationCeremony(target.KeyId, signer, {
+      ...options,
+      payload: options?.payload ?? hash
+    });
     return this.signHashWithWebAuthn(hash, assertion.ChallengeId, assertion.Credential, target);
   }
-  /** Sign EIP-712 typed data, running the challenge-binding ceremony internally. */
+  /**
+   * Sign EIP-712 typed data, running the challenge-binding ceremony internally.
+   * Auto-binds the WYSIWYS commitment (#68): the ceremony challenge is
+   * `SHA-256(nonce ‖ eip712Digest)`, where `eip712Digest` is the standard EIP-712
+   * digest the KMS hashes host-side — computed here via {@link eip712Digest} so the
+   * user's signature commits to the exact typed-data payload. Pass an explicit
+   * `options.payload` only to override.
+   */
   async signTypedDataWithCeremony(params, signer, options) {
     this.ensureEnabled();
-    const webAuthnAssertion = await this.runAuthenticationCeremony(params.keyId, signer, options);
+    const payload = options?.payload ?? eip712Digest(params);
+    const webAuthnAssertion = await this.runAuthenticationCeremony(params.keyId, signer, {
+      ...options,
+      payload
+    });
     return this.signTypedDataWithWebAuthn({ ...params, webAuthnAssertion });
   }
   /**
@@ -4566,7 +4760,10 @@ var KmsManager = class {
    */
   async signGrantSessionWithCeremony(params, signer, options) {
     this.ensureEnabled();
-    const webAuthnAssertion = await this.runGrantSessionCeremony(params.keyId, signer, options);
+    const webAuthnAssertion = await this.runGrantSessionCeremony(params.keyId, signer, {
+      ...options,
+      payload: options?.payload ?? grantSessionFinalHash(params)
+    });
     return this.signGrantSession({ ...params, webAuthnAssertion });
   }
   /**
@@ -4575,7 +4772,10 @@ var KmsManager = class {
    */
   async signP256GrantSessionWithCeremony(params, signer, options) {
     this.ensureEnabled();
-    const webAuthnAssertion = await this.runGrantSessionCeremony(params.keyId, signer, options);
+    const webAuthnAssertion = await this.runGrantSessionCeremony(params.keyId, signer, {
+      ...options,
+      payload: options?.payload ?? grantSessionFinalHash(params)
+    });
     return this.signP256GrantSession({ ...params, webAuthnAssertion });
   }
   // ── WebAuthn Ceremonies ─────────────────────────────────────────
@@ -4632,7 +4832,7 @@ var KmsManager = class {
    * @param ceremonySigner authenticator that signs the WebAuthn challenge
    *   (a browser passkey on the client, or {@link P256PasskeySigner} server-side).
    */
-  createKmsSignerWithCeremony(keyId, address, ceremonySigner, ceremonyOptions, commitPayload = false) {
+  createKmsSignerWithCeremony(keyId, address, ceremonySigner, ceremonyOptions, commitPayload = true) {
     this.ensureEnabled();
     return new KmsSigner(keyId, address, this, {
       mode: "ceremony",
@@ -4760,7 +4960,15 @@ var KmsAgentService = class {
   // challenge bound to the HUMAN key. These helpers run the full ceremony
   // (begin → clientDataJSON → assertion) via the shared
   // {@link runAuthenticationCeremony} helper, then invoke the endpoint.
-  /** Mint an agent key, running the challenge-binding ceremony internally. */
+  /**
+   * Mint an agent key, running the challenge-binding ceremony internally.
+   *
+   * STRICT MODE (AirAccount #115): bind the mint params by passing `options.payload =
+   * mintDigest({ kind: "agent", walletId, index, ttlSecs, subject })` — `index` is the
+   * agent_index the KMS will assign (query it first), `subject` the JWT sub (human key id),
+   * `ttlSecs` the JWT lifetime. Without a payload the ceremony sends the raw nonce, which
+   * strict mode rejects.
+   */
   async createAgentKeyWithCeremony(params, signer, options) {
     this.http.ensureEnabled();
     const webAuthnAssertion = await runAuthenticationCeremony(
@@ -4847,7 +5055,15 @@ var KmsSessionService = class {
   // Create + revoke gate on the generic purpose="authentication" challenge bound
   // to the HUMAN key. These helpers run the full ceremony (begin → clientDataJSON
   // → assertion) via the shared {@link runAuthenticationCeremony} helper.
-  /** Create a P-256 session key, running the challenge-binding ceremony internally. */
+  /**
+   * Create a P-256 session key, running the challenge-binding ceremony internally.
+   *
+   * STRICT MODE (AirAccount #115): bind the mint params by passing `options.payload =
+   * mintDigest({ kind: "p256", walletId, index, ttlSecs, subject })` — `index` is the
+   * session_index the KMS will assign (query it first), `subject` the JWT sub (human key
+   * id), `ttlSecs` the JWT lifetime. Without a payload the ceremony sends the raw nonce,
+   * which strict mode rejects.
+   */
   async createP256SessionKeyWithCeremony(params, signer, options) {
     this.http.ensureEnabled();
     const webAuthnAssertion = await runAuthenticationCeremony(
@@ -4911,7 +5127,108 @@ var KmsPaymentSigner = class {
     this.http.ensureEnabled();
     return this.signWithAuth("/kms/SignX402Payment", { ...params }, auth);
   }
+  // ── Ceremony-internal variants with WYSIWYS payload commitment (#68 / #135 item 1) ──
+  // Each payment endpoint is a fixed-schema SignTypedData host-side, so the commitment
+  // payload is the EIP-712 digest of that schema. We compute it SDK-side (digest helpers
+  // below, schemas mirrored from kms/host/src/api_server.rs) and bind the ceremony
+  // challenge to it: challenge = SHA-256(nonce ‖ eip712Digest). Live-verified against KMS.
+  /** Sign a MicroPaymentChannel voucher, running the committed ceremony internally. */
+  async signMicropaymentVoucherWithCeremony(params, signer, options) {
+    this.http.ensureEnabled();
+    const webAuthnAssertion = await runAuthenticationCeremony(this.http, params.keyId, signer, {
+      ...options,
+      payload: micropaymentVoucherDigest(params)
+    });
+    return this.signMicropaymentVoucher(params, { webAuthnAssertion });
+  }
+  /** Sign a GToken EIP-3009 authorization, running the committed ceremony internally. */
+  async signGTokenAuthorizationWithCeremony(params, signer, options) {
+    this.http.ensureEnabled();
+    const webAuthnAssertion = await runAuthenticationCeremony(this.http, params.keyId, signer, {
+      ...options,
+      payload: gTokenAuthorizationDigest(params)
+    });
+    return this.signGTokenAuthorization(params, { webAuthnAssertion });
+  }
+  /** Sign an x402 payment, running the committed ceremony internally. */
+  async signX402PaymentWithCeremony(params, signer, options) {
+    this.http.ensureEnabled();
+    const webAuthnAssertion = await runAuthenticationCeremony(this.http, params.keyId, signer, {
+      ...options,
+      payload: x402PaymentDigest(params)
+    });
+    return this.signX402Payment(params, { webAuthnAssertion });
+  }
 };
+function micropaymentVoucherDigest(p) {
+  return eip712Digest({
+    domain: { name: "MicroPaymentChannel", version: "1.0.0", chainId: p.chainId, verifyingContract: p.verifyingContract },
+    primaryType: "Voucher",
+    types: [
+      {
+        name: "Voucher",
+        fields: [
+          { name: "channelId", type: "bytes32" },
+          { name: "cumulativeAmount", type: "uint256" }
+        ]
+      }
+    ],
+    message: [
+      { name: "channelId", value: p.channelId },
+      { name: "cumulativeAmount", value: p.cumulativeAmount }
+    ]
+  });
+}
+function gTokenAuthorizationDigest(p) {
+  return eip712Digest({
+    domain: { name: "GToken", version: "1", chainId: p.chainId, verifyingContract: p.gTokenAddress },
+    primaryType: "TransferWithAuthorization",
+    types: [
+      {
+        name: "TransferWithAuthorization",
+        fields: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "validAfter", type: "uint256" },
+          { name: "validBefore", type: "uint256" },
+          { name: "nonce", type: "bytes32" }
+        ]
+      }
+    ],
+    message: [
+      { name: "from", value: p.from },
+      { name: "to", value: p.to },
+      { name: "value", value: p.value },
+      { name: "validAfter", value: p.validAfter },
+      { name: "validBefore", value: p.validBefore },
+      { name: "nonce", value: p.nonce }
+    ]
+  });
+}
+function x402PaymentDigest(p) {
+  return eip712Digest({
+    domain: { name: "SuperPaymaster", version: "1", chainId: p.chainId, verifyingContract: p.verifyingContract },
+    primaryType: "PaymentPayload",
+    types: [
+      {
+        name: "PaymentPayload",
+        fields: [
+          { name: "paymentId", type: "bytes32" },
+          { name: "amount", type: "uint256" },
+          { name: "recipient", type: "address" },
+          { name: "deadline", type: "uint256" }
+        ]
+      }
+    ],
+    message: [
+      { name: "paymentId", value: p.paymentId },
+      { name: "amount", value: p.amount },
+      { name: "recipient", value: p.recipient },
+      { name: "deadline", value: p.deadline }
+    ]
+  });
+}
 
 // ../airaccount/src/server/services/kms-monitor-service.ts
 var KmsMonitorService = class {
@@ -5204,14 +5521,19 @@ exports.buildInstallModuleHash = buildInstallModuleHash;
 exports.buildUninstallModuleHash = buildUninstallModuleHash;
 exports.commitChallenge = commitChallenge;
 exports.computeOapdSalt = computeOapdSalt;
+exports.eip712Digest = eip712Digest;
 exports.erc8004AddressesForChain = erc8004AddressesForChain;
+exports.gTokenAuthorizationDigest = gTokenAuthorizationDigest;
 exports.getOapdAddress = getOapdAddress;
 exports.getOapdAddressWithChainId = getOapdAddressWithChainId;
+exports.grantSessionFinalHash = grantSessionFinalHash;
 exports.initConfigFromRecord = initConfigFromRecord;
 exports.initConfigToTuple = initConfigToTuple;
 exports.isExecuteUserOpWrapped = isExecuteUserOpWrapped;
 exports.isOapdDeployed = isOapdDeployed;
 exports.isPendingConfirmation = isPendingConfirmation;
+exports.micropaymentVoucherDigest = micropaymentVoucherDigest;
+exports.mintDigest = mintDigest;
 exports.packP256SessionSignature = packP256SessionSignature;
 exports.packSecp256k1SessionSignature = packSecp256k1SessionSignature;
 exports.runAuthenticationCeremony = runAuthenticationCeremony;
@@ -5222,5 +5544,6 @@ exports.serializeGuardianSpecs = serializeGuardianSpecs;
 exports.toGuardianSpecs = toGuardianSpecs;
 exports.validateConfig = validateConfig;
 exports.wrapExecuteUserOp = wrapExecuteUserOp;
-//# sourceMappingURL=chunk-6IZASQSB.cjs.map
-//# sourceMappingURL=chunk-6IZASQSB.cjs.map
+exports.x402PaymentDigest = x402PaymentDigest;
+//# sourceMappingURL=chunk-UZE7IPOK.cjs.map
+//# sourceMappingURL=chunk-UZE7IPOK.cjs.map