@soropass/core 0.1.2 → 0.2.1

package/dist/create.d.ts

@@ -1,10 +1,10 @@
-import { P as PasskeyCredential } from './types-C3VIw5Iu.js';
-export { d as assertES256, e as assertUserActivation } from './types-C3VIw5Iu.js';
-import { A as AccountDeployer, W as WebAuthnClient, C as CredentialStorage } from './types--WNl-Sda.js';
-export { g as buildCreateOptions } from './types--WNl-Sda.js';
-import './checkAuth-C2AcXqFe.js';
+import { P as PasskeyCredential } from './types-BJsL-q2B.js';
+export { d as assertES256, e as assertUserActivation } from './types-BJsL-q2B.js';
+import { A as AccountDeployer, W as WebAuthnClient, C as CredentialStorage } from './types-CJluKV7s.js';
+export { g as buildCreateOptions } from './types-CJluKV7s.js';
+import './checkAuth-B5ObsEsP.js';
 import '@stellar/stellar-sdk';
-import './sign-B4JV2Inn.js';
+import './sign-O5d7Moma.js';
 
 interface CreatePasskeyOptions {
     rpId: string;
@@ -66,17 +66,25 @@ declare function extractPublicKeyFromAttestationObject(attestationObject: Uint8A
 interface DeriveAccountAddressOptions {
     /** The AccountFactory contract C-address — the deployer. */
     factoryContractId: string;
-    /** The credential-id bytes the factory salts by SHA-256 (utf-8 of the base64url id in our factory). */
+    /** The credential-id bytes the factory salts (utf-8 of the base64url id in our factory). */
     credentialId: Uint8Array;
+    /**
+     * SEC-1 (65-byte) public key of the founding passkey. The v0.2 factory binds
+     * it into the deploy salt (`sha256(credential_id ‖ public_key)`) so a public
+     * credential id alone cannot be used to squat a derived address.
+     */
+    publicKey: Uint8Array;
     networkPassphrase: string;
 }
 /**
  * Derive the deterministic C-address of the `webauthn-account` our AccountFactory
- * deploys for a passkey — with NO network round-trip. The factory salts by
- * `sha256(credential_id)` and deploys with `deployer().with_current_contract(salt)`.
- * Verified against the on-chain `factoryDeployProof` in `contracts/deployments.json`
- * (credential `democred` → `CAGWE36M…`). For the passkey-kit v1 smart-wallet, use
- * {@link deriveSmartWalletAddress} instead (different deployer + salt-input scheme).
+ * deploys for a passkey — with NO network round-trip. The v0.2 factory salts by
+ * `sha256(credential_id ‖ public_key)` and deploys with
+ * `deployer().with_current_contract(salt)`. Binding the public key is the F1
+ * fix: a credential id is public (the factory emits it), so salting by it alone
+ * let anyone pre-deploy at a victim's address with their own key. For the
+ * passkey-kit v1 smart-wallet, use {@link deriveSmartWalletAddress} instead
+ * (different deployer + salt-input scheme).
  */
 declare function deriveAccountAddress(options: DeriveAccountAddressOptions): string;
 interface DeriveSmartWalletAddressOptions {

package/dist/create.js

@@ -1,5 +1,5 @@
-export { deriveAccountAddress, deriveSmartWalletAddress } from './chunk-MMB4ZIW3.js';
-export { buildCreateOptions, coseKeyToSec1, createPasskey, extractPublicKeyFromAttestationObject, extractPublicKeyFromAuthData, registerPasskey } from './chunk-W75OQKHR.js';
+export { deriveAccountAddress, deriveSmartWalletAddress } from './chunk-OHKPNVB3.js';
+export { buildCreateOptions, coseKeyToSec1, createPasskey, extractPublicKeyFromAttestationObject, extractPublicKeyFromAuthData, registerPasskey } from './chunk-RFMHMWTY.js';
 import './chunk-JNJ2FY45.js';
 export { browserWebAuthnClient, defaultCredentialStorage } from './chunk-LB4HOTLV.js';
 export { assertES256, assertUserActivation } from './chunk-TPBBZNPP.js';

package/dist/index.cjs

@@ -91,7 +91,9 @@ function buildCreateOptions(input) {
     authenticatorSelection: {
       residentKey,
       requireResidentKey: residentKey === "required",
-      userVerification: input.userVerification ?? "preferred"
+      // The v0.2 account requires the User-Verified flag at sign time, so
+      // register with 'required' to enroll authenticators that can produce it.
+      userVerification: input.userVerification ?? "required"
     },
     attestation: "none",
     timeout: input.timeout ?? 6e4
@@ -534,14 +536,22 @@ function contractIdFromDeployerSalt(deployer, salt, networkPassphrase) {
   return stellarSdk.StrKey.encodeContract(stellarSdk.hash(preimage.toXDR()));
 }
 function deriveAccountAddress(options) {
-  const { factoryContractId, credentialId, networkPassphrase } = options;
+  const { factoryContractId, credentialId, publicKey, networkPassphrase } = options;
   if (credentialId.length === 0) {
     throw new KitError("CONTRACT_AUTH_FAILED", "deriveAccountAddress: empty credential id");
   }
+  if (publicKey.length !== 65) {
+    throw new KitError(
+      "CONTRACT_AUTH_FAILED",
+      `deriveAccountAddress: public key must be 65-byte SEC-1 (got ${String(publicKey.length)})`
+    );
+  }
+  const saltInput = new Uint8Array(credentialId.length + publicKey.length);
+  saltInput.set(credentialId, 0);
+  saltInput.set(publicKey, credentialId.length);
   return contractIdFromDeployerSalt(
     factoryContractId,
-    stellarSdk.hash(Buffer.from(credentialId)),
-    // e.crypto().sha256(credential_id)
+    stellarSdk.hash(Buffer.from(saltInput)),
     networkPassphrase
   );
 }
@@ -605,13 +615,16 @@ function browserPasskeySigner(options) {
       rpId: options.rpId,
       challenge: base64UrlToBytes(challenge),
       allowCredentials: options.allowCredentials ?? [],
-      userVerification: options.userVerification ?? "preferred"
+      // The v0.2 account requires the User-Verified flag, so default to
+      // 'required'; a signature without UV fails on-chain.
+      userVerification: options.userVerification ?? "required"
     });
     return {
       authenticatorData: assertion.authenticatorData,
       clientDataJSON: assertion.clientDataJSON,
       signature: assertion.signature,
-      credentialId: assertion.rawId
+      credentialId: assertion.rawId,
+      publicKey: options.publicKey
     };
   };
 }
@@ -634,10 +647,24 @@ function authEntryChallengeBytes(entry, networkPassphrase) {
 function authEntryChallenge(entry, networkPassphrase) {
   return bytesToBase64Url(authEntryChallengeBytes(entry, networkPassphrase));
 }
-function applyAssertionToEntry(entry, assertion) {
-  entry.credentials().address().signature(buildSignatureScVal(assertion));
+function applyAssertionToEntry(entry, assertion, publicKey) {
+  entry.credentials().address().signature(buildSingleSignerSignatureScVal(assertion, publicKey));
   return entry;
 }
+function buildSingleSignerSignatureScVal(assertion, publicKey) {
+  if (publicKey.length !== 65) {
+    throw new KitError(
+      "CONTRACT_AUTH_FAILED",
+      `single-signer signature needs a 65-byte SEC-1 public key (got ${String(publicKey.length)})`
+    );
+  }
+  return stellarSdk.xdr.ScVal.scvMap([
+    bytesField("authenticator_data", assertion.authenticatorData),
+    bytesField("client_data_json", assertion.clientDataJSON),
+    bytesField("public_key", publicKey),
+    bytesField("signature", assertion.signature)
+  ]);
+}
 function buildSignatureScVal(assertion) {
   return stellarSdk.xdr.ScVal.scvMap([
     bytesField("authenticator_data", assertion.authenticatorData),
@@ -790,7 +817,14 @@ async function signEntryInPlace(entry, options) {
   if (options.target === "smart-wallet") {
     applyAssertionToSmartWalletEntry(entry, normalized);
   } else {
-    applyAssertionToEntry(entry, normalized);
+    const publicKey = options.publicKey ?? assertion.publicKey;
+    if (publicKey === void 0) {
+      throw new KitError(
+        "CONTRACT_AUTH_FAILED",
+        "single-signer signing requires the signer public key: set SorobanSignOptions.publicKey or return publicKey from the signer"
+      );
+    }
+    applyAssertionToEntry(entry, normalized, publicKey);
   }
 }
 async function signAuthEntry(entryXdr, options) {
@@ -926,17 +960,26 @@ function verifySecp256r1StructMap(structMap, publicKey, signaturePayload) {
   }
   const digest = sha256.sha256(concatBytes(authenticatorData, sha256.sha256(clientDataJSON)));
   const signatureValid = nist.p256.verify(signature, digest, publicKey, {
-    lowS: false,
+    lowS: true,
     format: "compact"
   });
   return { ok: challengeBound && signatureValid, challengeBound, signatureValid };
 }
+function bytesEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
 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 inline = structMap.find((x) => x.key().sym().toString() === "public_key");
+  if (inline && !bytesEqual(new Uint8Array(inline.val().bytes()), publicKey)) {
+    return fail("unknown signer: inline public_key is not the enrolled key");
+  }
   const signaturePayload = authEntryChallengeBytes(entry, networkPassphrase);
   const r = verifySecp256r1StructMap(structMap, publicKey, signaturePayload);
   return { success: r.ok, challengeBound: r.challengeBound, signatureValid: r.signatureValid };
@@ -1108,8 +1151,20 @@ async function connect(options) {
     }
   }
   const accounts = await options.indexer.resolveByCredential(credentialId);
-  const contractId = accounts[0]?.contractId;
-  return contractId ? { contractId, credentialId } : null;
+  const selected = selectAccount(accounts, options.publicKey);
+  return selected ? { contractId: selected.contractId, credentialId } : null;
+}
+function bytesEqual2(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+}
+function selectAccount(accounts, publicKey) {
+  if (publicKey) {
+    const match = accounts.find((a) => a.publicKey && bytesEqual2(a.publicKey, publicKey));
+    return match ? { contractId: match.contractId } : null;
+  }
+  return accounts[0] ?? null;
 }
 
 // src/ceremonies/recover.ts
@@ -1292,7 +1347,10 @@ function defaultMatch(event, credentialId) {
       const cred = credRaw instanceof Uint8Array ? new TextDecoder().decode(credRaw) : String(credRaw ?? "");
       if (tag === "deployed" && cred === credentialId) {
         const addr2 = decodeNative(event.value);
-        if (typeof addr2 === "string" && addr2.startsWith("C")) return { contractId: addr2 };
+        const pkRaw = topics.length >= 3 ? decodeNative(topics[2]) : void 0;
+        const publicKey = pkRaw instanceof Uint8Array ? pkRaw : void 0;
+        if (typeof addr2 === "string" && addr2.startsWith("C"))
+          return { contractId: addr2, publicKey };
       }
     }
     const haystack = [event.value, ...topics].map((v) => v.toXDR("base64")).join("|");
@@ -1375,6 +1433,12 @@ function factoryDeployer(options) {
   const source = stellarSdk.Keypair.fromSecret(options.sourceSecret);
   return {
     async deploy(input) {
+      if (input.publicKey.length !== 65) {
+        throw new KitError(
+          "CONTRACT_AUTH_FAILED",
+          `factory deploy: public key must be 65-byte SEC-1 (got ${String(input.publicKey.length)})`
+        );
+      }
       const pk = stellarSdk.nativeToScVal(Buffer.from(input.publicKey), { type: "bytes" });
       const cred = stellarSdk.nativeToScVal(Buffer.from(new TextEncoder().encode(input.credentialId)), {
         type: "bytes"