@soropass/core 0.1.0

package/dist/sign.cjs

@@ -0,0 +1,883 @@
+'use strict';
+
+var nist = require('@noble/curves/nist');
+var sha256 = require('@noble/hashes/sha256');
+var stellarSdk = require('@stellar/stellar-sdk');
+
+// src/webauthn/signature.ts
+var KitError = class _KitError extends Error {
+  code;
+  name = "KitError";
+  constructor(code, message, options) {
+    super(message ?? code, options);
+    this.code = code;
+    Object.setPrototypeOf(this, _KitError.prototype);
+  }
+};
+
+// src/webauthn/signature.ts
+var MAX_DER_LENGTH = 72;
+function derToCompact(der) {
+  if (der.length > MAX_DER_LENGTH) {
+    throw new KitError(
+      "INVALID_SIGNATURE_DER",
+      `DER signature is ${der.length} bytes, exceeds max ${MAX_DER_LENGTH}`
+    );
+  }
+  try {
+    return nist.p256.Signature.fromDER(der).toCompactRawBytes();
+  } catch (cause) {
+    throw new KitError("INVALID_SIGNATURE_DER", "failed to parse DER signature", { cause });
+  }
+}
+function assertCompactLength(compactSignature) {
+  if (compactSignature.length !== 64) {
+    throw new KitError(
+      "INVALID_SIGNATURE_DER",
+      `compact signature must be 64 bytes, got ${compactSignature.length}`
+    );
+  }
+}
+function isLowS(compactSignature) {
+  assertCompactLength(compactSignature);
+  return !nist.p256.Signature.fromCompact(compactSignature).hasHighS();
+}
+function normalizeLowS(compactSignature) {
+  assertCompactLength(compactSignature);
+  return nist.p256.Signature.fromCompact(compactSignature).normalizeS().toCompactRawBytes();
+}
+function derToCompactLowS(der) {
+  return normalizeLowS(derToCompact(der));
+}
+
+// src/internal/bytes.ts
+function concatBytes(...arrays) {
+  const total = arrays.reduce((n, a) => n + a.length, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+}
+function equalBytes(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i += 1) diff |= (a[i] ?? 0) ^ (b[i] ?? 0);
+  return diff === 0;
+}
+
+// src/webauthn/payload.ts
+function reconstructSignedPayload(input) {
+  const clientDataHash = sha256.sha256(input.clientDataJSON);
+  return sha256.sha256(concatBytes(input.authenticatorData, clientDataHash));
+}
+
+// src/internal/encoding.ts
+function bytesToBase64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlToBytes(input) {
+  const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+  const binary = atob(padded);
+  const out = new Uint8Array(new ArrayBuffer(binary.length));
+  for (let i = 0; i < binary.length; i += 1) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function utf8ToBytes(text) {
+  return new TextEncoder().encode(text);
+}
+function bytesToUtf8(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+
+// src/webauthn/clientData.ts
+function encodeChallenge(challenge) {
+  return bytesToBase64Url(challenge);
+}
+function decodeChallenge(challenge) {
+  return base64UrlToBytes(challenge);
+}
+function parseClientDataJSON(clientDataJSON) {
+  let raw;
+  try {
+    raw = JSON.parse(bytesToUtf8(clientDataJSON));
+  } catch (cause) {
+    throw new KitError("UNSUPPORTED_AUTHENTICATOR", "clientDataJSON is not valid JSON", { cause });
+  }
+  if (typeof raw !== "object" || raw === null) {
+    throw new KitError("UNSUPPORTED_AUTHENTICATOR", "clientDataJSON is not a JSON object");
+  }
+  const obj = raw;
+  const { type, challenge, origin, crossOrigin } = obj;
+  if (typeof type !== "string" || typeof challenge !== "string" || typeof origin !== "string") {
+    throw new KitError("UNSUPPORTED_AUTHENTICATOR", "clientDataJSON is missing required fields");
+  }
+  return {
+    type,
+    challenge,
+    origin,
+    crossOrigin: typeof crossOrigin === "boolean" ? crossOrigin : void 0
+  };
+}
+function verifyClientDataJSON(clientDataJSON, expected) {
+  const data = parseClientDataJSON(clientDataJSON);
+  if (data.type !== "webauthn.get") {
+    throw new KitError(
+      "UNSUPPORTED_AUTHENTICATOR",
+      `clientDataJSON.type "${data.type}" is not "webauthn.get"`
+    );
+  }
+  const allowed = Array.isArray(expected.origin) ? expected.origin : [expected.origin];
+  if (!allowed.includes(data.origin)) {
+    throw new KitError("ORIGIN_MISMATCH", `origin "${data.origin}" not in [${allowed.join(", ")}]`);
+  }
+  if (data.challenge !== expected.challenge) {
+    throw new KitError("CHALLENGE_MISMATCH", "clientDataJSON challenge does not match expected");
+  }
+  return data;
+}
+
+// src/internal/cbor.ts
+function byteAt(bytes, index) {
+  const value = bytes[index];
+  if (value === void 0) throw new Error(`CBOR: unexpected end of input at byte ${index}`);
+  return value;
+}
+var MAX_DEPTH = 16;
+function decodeCbor(bytes, offset = 0, depth = 0) {
+  if (depth > MAX_DEPTH) throw new Error("CBOR: maximum nesting depth exceeded");
+  const first = byteAt(bytes, offset);
+  const major = first >> 5;
+  const info = first & 31;
+  let pos = offset + 1;
+  let argument;
+  if (info < 24) {
+    argument = info;
+  } else if (info === 24) {
+    argument = byteAt(bytes, pos);
+    pos += 1;
+  } else if (info === 25) {
+    argument = byteAt(bytes, pos) << 8 | byteAt(bytes, pos + 1);
+    pos += 2;
+  } else if (info === 26) {
+    argument = byteAt(bytes, pos) * 16777216 + (byteAt(bytes, pos + 1) << 16) + (byteAt(bytes, pos + 2) << 8) + byteAt(bytes, pos + 3);
+    pos += 4;
+  } else {
+    throw new Error(`CBOR: unsupported length encoding (additional info ${info})`);
+  }
+  switch (major) {
+    case 0:
+      return { value: argument, length: pos - offset };
+    case 1:
+      return { value: -1 - argument, length: pos - offset };
+    case 2: {
+      const end = pos + argument;
+      if (end > bytes.length) throw new Error("CBOR: byte string exceeds input");
+      return { value: bytes.slice(pos, end), length: end - offset };
+    }
+    case 3: {
+      const end = pos + argument;
+      if (end > bytes.length) throw new Error("CBOR: text string exceeds input");
+      return { value: new TextDecoder().decode(bytes.slice(pos, end)), length: end - offset };
+    }
+    case 4: {
+      const items = [];
+      let cursor = pos;
+      for (let i = 0; i < argument; i += 1) {
+        const item = decodeCbor(bytes, cursor, depth + 1);
+        items.push(item.value);
+        cursor += item.length;
+      }
+      return { value: items, length: cursor - offset };
+    }
+    case 5: {
+      const map = /* @__PURE__ */ new Map();
+      let cursor = pos;
+      for (let i = 0; i < argument; i += 1) {
+        const key = decodeCbor(bytes, cursor, depth + 1);
+        cursor += key.length;
+        const val = decodeCbor(bytes, cursor, depth + 1);
+        cursor += val.length;
+        if (typeof key.value !== "number" && typeof key.value !== "string") {
+          throw new Error("CBOR: unsupported map key type");
+        }
+        if (map.has(key.value)) {
+          throw new Error("CBOR: duplicate map key (non-canonical)");
+        }
+        map.set(key.value, val.value);
+      }
+      return { value: map, length: cursor - offset };
+    }
+    default:
+      throw new Error(`CBOR: unsupported major type ${major}`);
+  }
+}
+
+// src/webauthn/authData.ts
+var MIN_LENGTH = 37;
+function parseAuthenticatorData(authData) {
+  if (authData.length < MIN_LENGTH) {
+    throw new KitError(
+      "UNSUPPORTED_AUTHENTICATOR",
+      `authenticatorData is ${authData.length} bytes, expected at least ${MIN_LENGTH}`
+    );
+  }
+  const view = new DataView(authData.buffer, authData.byteOffset, authData.byteLength);
+  const rpIdHash = authData.slice(0, 32);
+  const bits = authData[32] ?? 0;
+  const flags = {
+    up: (bits & 1) !== 0,
+    uv: (bits & 4) !== 0,
+    be: (bits & 8) !== 0,
+    bs: (bits & 16) !== 0,
+    at: (bits & 64) !== 0,
+    ed: (bits & 128) !== 0,
+    bits
+  };
+  const signCount = view.getUint32(33, false);
+  const result = { rpIdHash, flags, signCount };
+  if (flags.at) {
+    if (authData.length < 55) {
+      throw new KitError(
+        "UNSUPPORTED_AUTHENTICATOR",
+        "authenticatorData truncated in attested data"
+      );
+    }
+    result.aaguid = authData.slice(37, 53);
+    const credIdLength = view.getUint16(53, false);
+    const credIdEnd = 55 + credIdLength;
+    if (authData.length < credIdEnd) {
+      throw new KitError(
+        "UNSUPPORTED_AUTHENTICATOR",
+        "authenticatorData truncated in credentialId"
+      );
+    }
+    result.credentialId = authData.slice(55, credIdEnd);
+    const rest = authData.slice(credIdEnd);
+    const { length } = decodeCbor(rest, 0);
+    result.credentialPublicKey = rest.slice(0, length);
+  }
+  return result;
+}
+function verifyRpIdHash(authData, rpId) {
+  const actual = parseAuthenticatorData(authData).rpIdHash;
+  const expected = sha256.sha256(utf8ToBytes(rpId));
+  if (!equalBytes(actual, expected)) {
+    throw new KitError(
+      "RP_ID_MISMATCH",
+      `authenticatorData rpIdHash does not match SHA-256("${rpId}")`
+    );
+  }
+}
+function verifyAssertionSignature(input) {
+  const payload = reconstructSignedPayload(input);
+  const compact = input.signature.length === 64 ? input.signature : derToCompact(input.signature);
+  return nist.p256.verify(compact, payload, input.publicKey, { lowS: false, format: "compact" });
+}
+
+// src/ceremonies/random.ts
+function randomBytes(length) {
+  const webcrypto = globalThis.crypto;
+  if (typeof webcrypto?.getRandomValues !== "function") {
+    throw new KitError(
+      "UNSUPPORTED_AUTHENTICATOR",
+      "no secure random source (globalThis.crypto.getRandomValues) is available in this environment"
+    );
+  }
+  const out = new Uint8Array(new ArrayBuffer(length));
+  webcrypto.getRandomValues(out);
+  return out;
+}
+
+// src/ceremonies/browserClient.ts
+function asKitError(error) {
+  if (error instanceof KitError) return error;
+  const name = typeof error === "object" && error !== null && "name" in error ? error.name : void 0;
+  if (name === "NotAllowedError") {
+    return new KitError("USER_CANCELLED", "The passkey prompt was dismissed.", { cause: error });
+  }
+  const message = error instanceof Error ? error.message : "WebAuthn request failed";
+  const detail = typeof name === "string" ? `${name}: ${message}` : message;
+  return new KitError("UNSUPPORTED_AUTHENTICATOR", detail, { cause: error });
+}
+function browserWebAuthnClient() {
+  const credentials = globalThis.navigator?.credentials;
+  if (!credentials) {
+    throw new KitError("UNSUPPORTED_AUTHENTICATOR", "navigator.credentials is unavailable");
+  }
+  return {
+    async create(options) {
+      const publicKey = {
+        challenge: base64UrlToBytes(options.challenge),
+        rp: options.rp,
+        user: {
+          id: base64UrlToBytes(options.user.id),
+          name: options.user.name,
+          displayName: options.user.displayName
+        },
+        pubKeyCredParams: options.pubKeyCredParams,
+        authenticatorSelection: options.authenticatorSelection,
+        attestation: options.attestation,
+        timeout: options.timeout
+      };
+      let credential;
+      try {
+        credential = await credentials.create({ publicKey });
+      } catch (error) {
+        throw asKitError(error);
+      }
+      if (!credential) throw new KitError("USER_CANCELLED", "credential creation returned null");
+      const response = credential.response;
+      return {
+        id: credential.id,
+        rawId: new Uint8Array(credential.rawId),
+        attestationObject: new Uint8Array(response.attestationObject)
+      };
+    },
+    async get(options) {
+      const publicKey = {
+        rpId: options.rpId,
+        challenge: options.challenge ? new Uint8Array(options.challenge) : randomBytes(32),
+        allowCredentials: (options.allowCredentials ?? []).map((id) => ({
+          type: "public-key",
+          id: base64UrlToBytes(id)
+        })),
+        userVerification: options.userVerification
+      };
+      const request = { publicKey };
+      if (options.mediation) request.mediation = options.mediation;
+      let credential;
+      try {
+        credential = await credentials.get(request);
+      } catch (error) {
+        throw asKitError(error);
+      }
+      if (!credential) throw new KitError("USER_CANCELLED", "assertion returned null");
+      const response = credential.response;
+      return {
+        id: credential.id,
+        rawId: new Uint8Array(credential.rawId),
+        authenticatorData: new Uint8Array(response.authenticatorData),
+        clientDataJSON: new Uint8Array(response.clientDataJSON),
+        signature: new Uint8Array(response.signature)
+      };
+    }
+  };
+}
+
+// src/ceremonies/browserSigner.ts
+function browserPasskeySigner(options) {
+  const webauthn = options.webauthn ?? browserWebAuthnClient();
+  return async (challenge) => {
+    const assertion = await webauthn.get({
+      rpId: options.rpId,
+      challenge: base64UrlToBytes(challenge),
+      allowCredentials: options.allowCredentials ?? [],
+      userVerification: options.userVerification ?? "preferred"
+    });
+    return {
+      authenticatorData: assertion.authenticatorData,
+      clientDataJSON: assertion.clientDataJSON,
+      signature: assertion.signature,
+      credentialId: assertion.rawId
+    };
+  };
+}
+function authEntryChallengeBytes(entry, networkPassphrase) {
+  const credentials = entry.credentials();
+  if (credentials.switch().name !== "sorobanCredentialsAddress") {
+    throw new KitError("CONTRACT_AUTH_FAILED", "auth entry has no address credentials to sign");
+  }
+  const address = credentials.address();
+  const preimage = stellarSdk.xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
+    new stellarSdk.xdr.HashIdPreimageSorobanAuthorization({
+      networkId: Buffer.from(stellarSdk.hash(Buffer.from(utf8ToBytes(networkPassphrase)))),
+      nonce: address.nonce(),
+      signatureExpirationLedger: address.signatureExpirationLedger(),
+      invocation: entry.rootInvocation()
+    })
+  );
+  return new Uint8Array(stellarSdk.hash(preimage.toXDR()));
+}
+function authEntryChallenge(entry, networkPassphrase) {
+  return bytesToBase64Url(authEntryChallengeBytes(entry, networkPassphrase));
+}
+function applyAssertionToEntry(entry, assertion) {
+  entry.credentials().address().signature(buildSignatureScVal(assertion));
+  return entry;
+}
+function buildSignatureScVal(assertion) {
+  return stellarSdk.xdr.ScVal.scvMap([
+    bytesField("authenticator_data", assertion.authenticatorData),
+    bytesField("client_data_json", assertion.clientDataJSON),
+    bytesField("signature", assertion.signature)
+  ]);
+}
+function bytesField(name, bytes) {
+  return new stellarSdk.xdr.ScMapEntry({
+    key: stellarSdk.xdr.ScVal.scvSymbol(name),
+    val: stellarSdk.xdr.ScVal.scvBytes(Buffer.from(bytes))
+  });
+}
+function buildSignerKeyScVal(credentialId) {
+  return stellarSdk.xdr.ScVal.scvVec([
+    stellarSdk.xdr.ScVal.scvSymbol("Secp256r1"),
+    stellarSdk.xdr.ScVal.scvBytes(Buffer.from(credentialId))
+  ]);
+}
+function buildSmartWalletSignatureVariant(assertion) {
+  return stellarSdk.xdr.ScVal.scvVec([stellarSdk.xdr.ScVal.scvSymbol("Secp256r1"), buildSignatureScVal(assertion)]);
+}
+function decomposeSignerKey(key) {
+  const vec = key.vec();
+  if (!vec || vec.length < 2) {
+    throw new KitError("CONTRACT_AUTH_FAILED", "malformed SignerKey (expected an enum vec)");
+  }
+  const variant = vec[0].sym().toString();
+  const el = vec[1];
+  const payload = el.switch().name === "scvBytes" ? new Uint8Array(el.bytes()) : new Uint8Array(el.toXDR());
+  return { variant, payload };
+}
+function compareBytes(a, b) {
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    if (a[i] !== b[i]) return a[i] < b[i] ? -1 : 1;
+  }
+  return a.length - b.length;
+}
+function compareSignerKeyScVal(a, b) {
+  const ka = decomposeSignerKey(a);
+  const kb = decomposeSignerKey(b);
+  if (ka.variant !== kb.variant) return ka.variant < kb.variant ? -1 : 1;
+  return compareBytes(ka.payload, kb.payload);
+}
+function applyAssertionToSmartWalletEntry(entry, assertion) {
+  const credentials = entry.credentials();
+  if (credentials.switch().name !== "sorobanCredentialsAddress") {
+    throw new KitError("CONTRACT_AUTH_FAILED", "auth entry has no address credentials to sign");
+  }
+  const key = buildSignerKeyScVal(assertion.credentialId);
+  const newEntry = new stellarSdk.xdr.ScMapEntry({ key, val: buildSmartWalletSignatureVariant(assertion) });
+  const current = credentials.address().signature();
+  let mapEntries;
+  switch (current.switch().name) {
+    case "scvVoid":
+      mapEntries = [newEntry];
+      break;
+    case "scvVec": {
+      const existing = current.vec()?.[0]?.map() ?? [];
+      mapEntries = existing.filter((e) => compareSignerKeyScVal(e.key(), key) !== 0);
+      mapEntries.push(newEntry);
+      break;
+    }
+    default:
+      throw new KitError(
+        "CONTRACT_AUTH_FAILED",
+        "unexpected existing signature shape for a smart-wallet entry"
+      );
+  }
+  mapEntries.sort((a, b) => compareSignerKeyScVal(a.key(), b.key()));
+  credentials.address().signature(stellarSdk.xdr.ScVal.scvVec([stellarSdk.xdr.ScVal.scvMap(mapEntries)]));
+  return entry;
+}
+
+// src/soroban/sign.ts
+function preflightAssertion(assertion, challenge, verify) {
+  let clientData;
+  if (verify.origin !== void 0) {
+    clientData = verifyClientDataJSON(assertion.clientDataJSON, {
+      origin: verify.origin,
+      challenge
+    });
+  } else {
+    clientData = parseClientDataJSON(assertion.clientDataJSON);
+    if (clientData.type !== "webauthn.get") {
+      throw new KitError(
+        "UNSUPPORTED_AUTHENTICATOR",
+        `clientDataJSON.type "${clientData.type}" is not "webauthn.get"`
+      );
+    }
+    if (clientData.challenge !== challenge) {
+      throw new KitError("CHALLENGE_MISMATCH", "assertion challenge does not match the auth entry");
+    }
+  }
+  if (clientData.crossOrigin === true && !verify.allowCrossOrigin) {
+    throw new KitError(
+      "ORIGIN_MISMATCH",
+      "assertion was made in a cross-origin context (crossOrigin=true)"
+    );
+  }
+  const parsed = parseAuthenticatorData(assertion.authenticatorData);
+  if (!parsed.flags.up) {
+    throw new KitError(
+      "UNSUPPORTED_AUTHENTICATOR",
+      "assertion is missing the User-Present (UP) flag"
+    );
+  }
+  if (verify.requireUserVerification && !parsed.flags.uv) {
+    throw new KitError(
+      "UNSUPPORTED_AUTHENTICATOR",
+      "assertion is missing the required User-Verified (UV) flag"
+    );
+  }
+  if (verify.rpId !== void 0) {
+    verifyRpIdHash(assertion.authenticatorData, verify.rpId);
+  }
+  if (verify.publicKey !== void 0) {
+    const ok = verifyAssertionSignature({
+      publicKey: verify.publicKey,
+      authenticatorData: assertion.authenticatorData,
+      clientDataJSON: assertion.clientDataJSON,
+      signature: assertion.signature
+    });
+    if (!ok) {
+      throw new KitError(
+        "CONTRACT_AUTH_FAILED",
+        "assertion signature failed pre-flight verification"
+      );
+    }
+  }
+}
+async function signEntryInPlace(entry, options) {
+  if (options.signatureExpirationLedger !== void 0) {
+    const creds = entry.credentials();
+    if (creds.switch().name === "sorobanCredentialsAddress") {
+      creds.address().signatureExpirationLedger(options.signatureExpirationLedger);
+    }
+  }
+  const challenge = authEntryChallenge(entry, options.networkPassphrase);
+  const assertion = await options.sign(challenge);
+  if (options.verify) preflightAssertion(assertion, challenge, options.verify);
+  const signature = assertion.signature.length === 64 ? assertion.signature : derToCompactLowS(assertion.signature);
+  const normalized = {
+    credentialId: assertion.credentialId,
+    authenticatorData: assertion.authenticatorData,
+    clientDataJSON: assertion.clientDataJSON,
+    signature
+  };
+  if (options.target === "smart-wallet") {
+    applyAssertionToSmartWalletEntry(entry, normalized);
+  } else {
+    applyAssertionToEntry(entry, normalized);
+  }
+}
+async function signAuthEntry(entryXdr, options) {
+  const entry = stellarSdk.xdr.SorobanAuthorizationEntry.fromXDR(entryXdr, "base64");
+  await signEntryInPlace(entry, options);
+  return entry.toXDR("base64");
+}
+function operationsForSigning(envelope) {
+  const kind = envelope.switch().name;
+  if (kind === "envelopeTypeTx") return envelope.v1().tx().operations();
+  if (kind === "envelopeTypeTxFeeBump") {
+    const inner = envelope.feeBump().tx().innerTx();
+    if (inner.switch().name !== "envelopeTypeTx") {
+      throw new KitError(
+        "CONTRACT_AUTH_FAILED",
+        "signTransaction: fee-bump inner transaction is not a v1 transaction"
+      );
+    }
+    return inner.v1().tx().operations();
+  }
+  throw new KitError(
+    "CONTRACT_AUTH_FAILED",
+    `signTransaction: unsupported envelope type "${kind}" (expected v1 or fee-bump)`
+  );
+}
+async function signTransaction(txXdr, options) {
+  const envelope = stellarSdk.xdr.TransactionEnvelope.fromXDR(txXdr, "base64");
+  for (const op of operationsForSigning(envelope)) {
+    if (op.body().switch().name !== "invokeHostFunction") continue;
+    const entries = op.body().invokeHostFunctionOp().auth();
+    for (const entry of entries) {
+      if (entry.credentials().switch().name !== "sorobanCredentialsAddress") continue;
+      await signEntryInPlace(entry, options);
+    }
+  }
+  return envelope.toXDR("base64");
+}
+function noneTuple() {
+  return stellarSdk.xdr.ScVal.scvVec([stellarSdk.xdr.ScVal.scvVoid()]);
+}
+function expirationScVal(expiration) {
+  if (expiration === void 0) return noneTuple();
+  const ts = BigInt(expiration);
+  if (ts < 0n) {
+    throw new KitError(
+      "CONTRACT_AUTH_FAILED",
+      "signer expiration must be a non-negative UNIX-seconds timestamp (v1)"
+    );
+  }
+  return stellarSdk.xdr.ScVal.scvVec([stellarSdk.nativeToScVal(ts, { type: "u64" })]);
+}
+function storageScVal(storage = "Persistent") {
+  return stellarSdk.xdr.ScVal.scvVec([stellarSdk.xdr.ScVal.scvSymbol(storage)]);
+}
+function buildSecp256r1Signer(spec) {
+  if (spec.credentialId.length === 0) {
+    throw new KitError("CONTRACT_AUTH_FAILED", "buildSecp256r1Signer: empty credential id");
+  }
+  if (spec.publicKey.length !== 65 || spec.publicKey[0] !== 4) {
+    throw new KitError(
+      "INVALID_PUBLIC_KEY",
+      "buildSecp256r1Signer: publicKey must be a 65-byte SEC-1 uncompressed point (0x04-prefixed)"
+    );
+  }
+  return stellarSdk.xdr.ScVal.scvVec([
+    stellarSdk.xdr.ScVal.scvSymbol("Secp256r1"),
+    stellarSdk.xdr.ScVal.scvBytes(Buffer.from(spec.credentialId)),
+    stellarSdk.xdr.ScVal.scvBytes(Buffer.from(spec.publicKey)),
+    expirationScVal(spec.expiration),
+    // SignerExpiration
+    noneTuple(),
+    // SignerLimits(None)
+    storageScVal(spec.storage)
+    // SignerStorage
+  ]);
+}
+function contractCall(contractId, method, ...args) {
+  let contract;
+  try {
+    contract = new stellarSdk.Contract(contractId);
+  } catch (cause) {
+    throw new KitError("CONTRACT_AUTH_FAILED", `invalid smart-wallet contract id "${contractId}"`, {
+      cause
+    });
+  }
+  return contract.call(method, ...args);
+}
+function buildAddSignerOperation(options) {
+  const signerScVal = options.signer instanceof stellarSdk.xdr.ScVal ? options.signer : buildSecp256r1Signer(options.signer);
+  return contractCall(options.walletContractId, "add_signer", signerScVal);
+}
+function buildRemoveSignerOperation(options) {
+  if (options.credentialId.length === 0) {
+    throw new KitError("CONTRACT_AUTH_FAILED", "buildRemoveSignerOperation: empty credential id");
+  }
+  return contractCall(
+    options.walletContractId,
+    "remove_signer",
+    buildSignerKeyScVal(options.credentialId)
+  );
+}
+function fail(reason) {
+  return { success: false, challengeBound: false, signatureValid: false, reason };
+}
+function verifySecp256r1StructMap(structMap, publicKey, signaturePayload) {
+  const field = (name) => {
+    const e = structMap.find((x) => x.key().sym().toString() === name);
+    return e ? new Uint8Array(e.val().bytes()) : void 0;
+  };
+  const authenticatorData = field("authenticator_data");
+  const clientDataJSON = field("client_data_json");
+  const signature = field("signature");
+  if (!authenticatorData || !clientDataJSON || !signature) {
+    return { ok: false, challengeBound: false, signatureValid: false, reason: "missing fields" };
+  }
+  if (signature.length !== 64) {
+    return {
+      ok: false,
+      challengeBound: false,
+      signatureValid: false,
+      reason: "not 64-byte compact"
+    };
+  }
+  let challengeBound = false;
+  try {
+    const cdj = JSON.parse(bytesToUtf8(clientDataJSON));
+    challengeBound = cdj.challenge === bytesToBase64Url(signaturePayload);
+  } catch {
+    challengeBound = false;
+  }
+  const digest = sha256.sha256(concatBytes(authenticatorData, sha256.sha256(clientDataJSON)));
+  const signatureValid = nist.p256.verify(signature, digest, publicKey, {
+    lowS: false,
+    format: "compact"
+  });
+  return { ok: challengeBound && signatureValid, challengeBound, signatureValid };
+}
+function referenceCheckAuth(entry, publicKey, networkPassphrase) {
+  if (entry.credentials().switch().name !== "sorobanCredentialsAddress") {
+    return fail("no address credentials");
+  }
+  const structMap = entry.credentials().address().signature().map();
+  if (!structMap) return fail("signature is not a Secp256r1Signature map");
+  const signaturePayload = authEntryChallengeBytes(entry, networkPassphrase);
+  const r = verifySecp256r1StructMap(structMap, publicKey, signaturePayload);
+  return { success: r.ok, challengeBound: r.challengeBound, signatureValid: r.signatureValid };
+}
+function referenceSmartWalletCheckAuth(entry, publicKeyFor, networkPassphrase) {
+  if (entry.credentials().switch().name !== "sorobanCredentialsAddress") {
+    return { success: false, signers: [], reason: "no address credentials" };
+  }
+  const sig = entry.credentials().address().signature();
+  const map = sig.switch().name === "scvVec" ? sig.vec()?.[0]?.map() : void 0;
+  if (!map) {
+    return { success: false, signers: [], reason: "signature is not a Signatures(Map) vec" };
+  }
+  if (map.length === 0) return { success: false, signers: [], reason: "empty signatures map" };
+  const signaturePayload = authEntryChallengeBytes(entry, networkPassphrase);
+  const signers = [];
+  let allOk = true;
+  for (const e of map) {
+    const keyVec = e.key().vec();
+    const idBytes = keyVec?.[1]?.bytes();
+    const credentialId = idBytes ? Buffer.from(idBytes).toString("hex") : "";
+    const structMap = e.val().vec()?.[1]?.map();
+    const publicKey = publicKeyFor(credentialId);
+    if (!structMap || !publicKey) {
+      allOk = false;
+      signers.push({ credentialId, challengeBound: false, signatureValid: false });
+      continue;
+    }
+    const r = verifySecp256r1StructMap(structMap, publicKey, signaturePayload);
+    if (!r.ok) allOk = false;
+    signers.push({
+      credentialId,
+      challengeBound: r.challengeBound,
+      signatureValid: r.signatureValid
+    });
+  }
+  return { success: allOk, signers };
+}
+function directSubmission(options) {
+  const server = new stellarSdk.rpc.Server(options.rpcUrl, {
+    allowHttp: options.allowHttp ?? options.rpcUrl.startsWith("http://")
+  });
+  const attempts = options.pollAttempts ?? 30;
+  const intervalMs = options.pollIntervalMs ?? 1e3;
+  return {
+    async send(signedTxXdr) {
+      const tx = stellarSdk.TransactionBuilder.fromXDR(signedTxXdr, options.networkPassphrase);
+      let sent;
+      try {
+        sent = await server.sendTransaction(tx);
+      } catch (cause) {
+        throw new KitError("NETWORK_ERROR", "failed to submit transaction to soroban-rpc", {
+          cause
+        });
+      }
+      if (sent.status === "ERROR") {
+        return {
+          status: "FAILED",
+          hash: sent.hash,
+          errorResultXdr: sent.errorResult?.toXDR("base64")
+        };
+      }
+      let final;
+      try {
+        final = await server.pollTransaction(sent.hash, {
+          attempts,
+          sleepStrategy: () => intervalMs
+        });
+      } catch (cause) {
+        throw new KitError(
+          "NETWORK_ERROR",
+          `transaction ${sent.hash} was not confirmed after ${String(attempts)} polls`,
+          { cause }
+        );
+      }
+      if (final.status === stellarSdk.rpc.Api.GetTransactionStatus.NOT_FOUND) {
+        throw new KitError(
+          "NETWORK_ERROR",
+          `transaction ${sent.hash} still NOT_FOUND after ${String(attempts)} polls`
+        );
+      }
+      const success = final.status === stellarSdk.rpc.Api.GetTransactionStatus.SUCCESS;
+      return {
+        status: success ? "SUCCESS" : "FAILED",
+        hash: sent.hash,
+        returnValue: success ? final.returnValue : void 0
+      };
+    }
+  };
+}
+
+// src/soroban/submit.ts
+var DEFAULT_EXPIRATION_OFFSET = 60;
+async function sendSmartWalletTx(options) {
+  const server = new stellarSdk.rpc.Server(options.rpcUrl, {
+    allowHttp: options.allowHttp ?? options.rpcUrl.startsWith("http://")
+  });
+  let source;
+  try {
+    source = stellarSdk.Keypair.fromSecret(options.sourceSecret);
+  } catch (cause) {
+    throw new KitError("CONTRACT_AUTH_FAILED", "invalid fee-source secret", { cause });
+  }
+  const account = await server.getAccount(source.publicKey());
+  const tx = new stellarSdk.TransactionBuilder(account, {
+    fee: options.fee ?? "2000000",
+    networkPassphrase: options.networkPassphrase
+  }).addOperation(options.operation).setTimeout(options.timeoutSeconds ?? 120).build();
+  const recSim = await server.simulateTransaction(tx);
+  if (!stellarSdk.rpc.Api.isSimulationSuccess(recSim)) {
+    const detail = "error" in recSim ? String(recSim.error) : "unknown simulation error";
+    throw new KitError(
+      "CONTRACT_AUTH_FAILED",
+      `smart-wallet tx simulation failed: ${detail.slice(0, 300)}`
+    );
+  }
+  const prepared = stellarSdk.rpc.assembleTransaction(tx, recSim).build();
+  const signatureExpirationLedger = (await server.getLatestLedger()).sequence + (options.signatureExpirationLedgerOffset ?? DEFAULT_EXPIRATION_OFFSET);
+  const signedAuthXdr = await signTransaction(prepared.toXDR(), {
+    networkPassphrase: options.networkPassphrase,
+    sign: options.sign,
+    target: "smart-wallet",
+    signatureExpirationLedger,
+    verify: options.verify
+  });
+  const signedTx = stellarSdk.TransactionBuilder.fromXDR(signedAuthXdr, options.networkPassphrase);
+  const enfSim = await server.simulateTransaction(signedTx);
+  if (!stellarSdk.rpc.Api.isSimulationSuccess(enfSim)) {
+    const detail = "error" in enfSim ? String(enfSim.error) : "unknown simulation error";
+    throw new KitError(
+      "CONTRACT_AUTH_FAILED",
+      `signed smart-wallet tx failed enforcing simulation (auth rejected?): ${detail.slice(0, 300)}`
+    );
+  }
+  const finalTx = stellarSdk.rpc.assembleTransaction(signedTx, enfSim).build();
+  finalTx.sign(source);
+  const submission = options.submission ?? directSubmission({
+    rpcUrl: options.rpcUrl,
+    networkPassphrase: options.networkPassphrase,
+    allowHttp: options.allowHttp
+  });
+  return submission.send(finalTx.toXDR());
+}
+
+exports.applyAssertionToEntry = applyAssertionToEntry;
+exports.applyAssertionToSmartWalletEntry = applyAssertionToSmartWalletEntry;
+exports.authEntryChallenge = authEntryChallenge;
+exports.authEntryChallengeBytes = authEntryChallengeBytes;
+exports.browserPasskeySigner = browserPasskeySigner;
+exports.buildAddSignerOperation = buildAddSignerOperation;
+exports.buildRemoveSignerOperation = buildRemoveSignerOperation;
+exports.buildSecp256r1Signer = buildSecp256r1Signer;
+exports.buildSignerKeyScVal = buildSignerKeyScVal;
+exports.buildSmartWalletSignatureVariant = buildSmartWalletSignatureVariant;
+exports.compareSignerKeyScVal = compareSignerKeyScVal;
+exports.decodeChallenge = decodeChallenge;
+exports.derToCompact = derToCompact;
+exports.derToCompactLowS = derToCompactLowS;
+exports.encodeChallenge = encodeChallenge;
+exports.isLowS = isLowS;
+exports.normalizeLowS = normalizeLowS;
+exports.parseAuthenticatorData = parseAuthenticatorData;
+exports.parseClientDataJSON = parseClientDataJSON;
+exports.reconstructSignedPayload = reconstructSignedPayload;
+exports.referenceCheckAuth = referenceCheckAuth;
+exports.referenceSmartWalletCheckAuth = referenceSmartWalletCheckAuth;
+exports.sendSmartWalletTx = sendSmartWalletTx;
+exports.signAuthEntry = signAuthEntry;
+exports.signTransaction = signTransaction;
+exports.verifyAssertionSignature = verifyAssertionSignature;
+exports.verifyClientDataJSON = verifyClientDataJSON;
+exports.verifyRpIdHash = verifyRpIdHash;
+//# sourceMappingURL=sign.cjs.map
+//# sourceMappingURL=sign.cjs.map