passkey-kit 0.2.5 → 0.4.0

package/src/kit.ts

@@ -1,51 +1,37 @@
 import { Client as PasskeyClient } from 'passkey-kit-sdk'
-import { Client as FactoryClient, networks } from 'passkey-factory-sdk'
-import { Address, Networks, StrKey, hash, xdr, Transaction, SorobanRpc, Operation, scValToNative, TransactionBuilder } from '@stellar/stellar-sdk'
-import { bufToBigint, bigintToBuf } from 'bigint-conversion'
+import { Client as FactoryClient } from 'passkey-factory-sdk'
+import { Address, Networks, StrKey, hash, xdr, Transaction, SorobanRpc, Operation, TransactionBuilder } from '@stellar/stellar-sdk'
 import base64url from 'base64url'
 import { startRegistration, startAuthentication } from "@simplewebauthn/browser"
+import type { AuthenticatorAttestationResponseJSON } from "@simplewebauthn/types"
 import { decode } from 'cbor-x/decode'
 import { Buffer } from 'buffer'
 import { PasskeyBase } from './base'
 
-/* TODO 
-    - Clean up these params and the interface as a whole
-        Might put wallet activities and maybe factory as well into the root of the class vs buried inside this.wallet and this.factory
-        @Later
-    - Right now publicKey can mean a Stellar public key or a passkey public key, there should be a noted difference
-*/
+type GetContractIdFunction = (keyId: string) => Promise<string>;
 
 export class PasskeyKit extends PasskeyBase {
     public keyId: string | undefined
-    public sudoKeyId: string | undefined
+    public keyExpired: boolean | undefined
     public wallet: PasskeyClient | undefined
     public factory: FactoryClient
     public networkPassphrase: Networks
     public rpcUrl: string
     public rpc: SorobanRpc.Server
-    public factoryContractId: string = networks.testnet.contractId
-
-    /* NOTE 
-        - Consider adding the ability to pass in a keyId and maybe even a contractId in order to preconnect to a wallet
-            If just a keyId call `connectWallet` in order to get the contractId
-            If both keyId and contractId are passed in then we can skip the connectWallet call (though we won't get the sudoKeyId in that case)
-            We don't strictly _need_ this as a dev can just call `connectWallet` after class instantiation but it might be a nice convenience
-            `connectWallet` is async making it tricky to know when the wallet is "ready". Thus I think it's better for `connectWallet` to be called externally
-            @No
-    */
+
     constructor(options: {
         rpcUrl: string,
         launchtubeUrl?: string,
         launchtubeJwt?: string,
-        factoryContractId?: string,
         networkPassphrase: string,
+        factoryContractId: string,
     }) {
         const {
             rpcUrl,
             launchtubeUrl,
             launchtubeJwt,
-            factoryContractId,
             networkPassphrase,
+            factoryContractId,
         } = options
 
         super({
@@ -53,21 +39,18 @@ export class PasskeyKit extends PasskeyBase {
             launchtubeJwt,
         })
 
-        if (factoryContractId)
-            this.factoryContractId = factoryContractId
-
         this.rpcUrl = rpcUrl
         this.rpc = new SorobanRpc.Server(rpcUrl)
         this.networkPassphrase = networkPassphrase as Networks
         this.factory = new FactoryClient({
-            contractId: this.factoryContractId,
+            contractId: factoryContractId,
             networkPassphrase,
             rpcUrl
         })
     }
 
-    public async createWallet(name: string, user: string) {
-        const { keyId, publicKey } = await this.createKey(name, user)
+    public async createWallet(app: string, user: string) {
+        const { keyId, publicKey } = await this.createKey(app, user)
 
         const { result, built } = await this.factory.deploy({
             id: keyId,
@@ -89,17 +72,19 @@ export class PasskeyKit extends PasskeyBase {
         }
     }
 
-    public async createKey(name: string, user: string) {
-        const startRegistrationResponse = await startRegistration({
+    public async createKey(app: string, user: string) {
+        const now = new Date()
+        const displayName = `${user} — ${now.toLocaleString()}`
+        const { id, response} = await startRegistration({
             challenge: base64url("stellaristhebetterblockchain"),
             rp: {
                 // id: undefined,
-                name,
+                name: app,
             },
-            user: {
-                id: base64url(user),
-                name: user,
-                displayName: user,
+            user: { // TODO there's a real danger here of overwriting a user's key if they use the same `user` name
+                id: base64url(`${user}:${now.getTime()}:${Math.random()}`),
+                name: displayName,
+                displayName
             },
             authenticatorSelection: {
                 requireResidentKey: false,
@@ -110,78 +95,89 @@ export class PasskeyKit extends PasskeyBase {
             attestation: "none",
         });
 
-        if (!this.keyId) {
-            this.keyId = startRegistrationResponse.id
-
-            // If there was no keyId we're likely about to deploy a new wallet so we should set the sudoKeyId 
-            if (!this.sudoKeyId)
-                this.sudoKeyId = startRegistrationResponse.id
-        }
-
-        const { publicKeyObject } = this.getPublicKeyObject(startRegistrationResponse.response.attestationObject);
+        if (!this.keyId)
+            this.keyId = id;
 
-        const publicKey = Buffer.from([
-            4, // (0x04 prefix) https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
-            ...publicKeyObject.get('-2')!,
-            ...publicKeyObject.get('-3')!
-        ])
+        const publicKey = this.getPublicKey(response);
 
         return {
-            keyId: base64url.toBuffer(startRegistrationResponse.id),
+            keyId: base64url.toBuffer(id),
             publicKey
         }
     }
 
-    public async connectWallet(keyId?: string) {
+    public async connectWallet(opts: {
+        keyId?: string | Uint8Array,
+        getContractId?: GetContractIdFunction
+    }) {
+        let { keyId, getContractId } = opts
+        let keyIdBuffer: Buffer
+
         if (!keyId) {
-            const { id } = await startAuthentication({
+            const response = await startAuthentication({
                 challenge: base64url("stellaristhebetterblockchain"),
                 // rpId: undefined,
                 userVerification: "discouraged",
             });
 
-            keyId = id
+            console.log(response);
+
+            keyId = response.id
+        }
+
+        if (keyId instanceof Uint8Array) {
+            keyIdBuffer = Buffer.from(keyId)
+            keyId = base64url(keyIdBuffer)
+        } else {
+            keyIdBuffer = base64url.toBuffer(keyId)
         }
 
         if (!this.keyId)
             this.keyId = keyId
 
-        const keyIdBuffer = base64url.toBuffer(keyId)
-
-        // NOTE might not need this for derivation as all signers are stored in the factory and we can use that lookup as both primary and secondary
-        let contractId = StrKey.encodeContract(hash(xdr.HashIdPreimage.envelopeTypeContractId(
+        // Check for the contractId on-chain as a derivation from the keyId. This is the easiest and "cheapest" check however it will only work for the initially deployed passkey if it was used as derivation
+        let contractId: string | undefined = StrKey.encodeContract(hash(xdr.HashIdPreimage.envelopeTypeContractId(
             new xdr.HashIdPreimageContractId({
                 networkId: hash(Buffer.from(this.networkPassphrase, 'utf-8')),
                 contractIdPreimage: xdr.ContractIdPreimage.contractIdPreimageFromAddress(
                     new xdr.ContractIdPreimageFromAddress({
-                        address: Address.fromString(this.factoryContractId).toScAddress(),
+                        address: Address.fromString(this.factory.options.contractId).toScAddress(),
                         salt: hash(keyIdBuffer),
                     })
                 )
             })
         ).toXDR()));
 
-        let contractData: SorobanRpc.Api.LedgerEntryResult | undefined
-
         // attempt passkey id derivation
         try {
-            contractData = await this.rpc.getContractData(contractId, xdr.ScVal.scvLedgerKeyContractInstance())
+            await this.rpc.getContractData(contractId, xdr.ScVal.scvLedgerKeyContractInstance())
         }
         // if that fails look up from the factory mapper
         catch {
-            const { val } = await this.rpc.getContractData(this.factoryContractId, xdr.ScVal.scvBytes(keyIdBuffer))
-            contractId = scValToNative(val.contractData().val())
+            contractId = undefined
+
+            if (getContractId) {
+                contractId = await getContractId(keyId)
+
+                // Handle case where temporary session signer is missing on-chain (so we can queue up a re-add)
+                try {
+                    await this.rpc.getContractData(contractId, xdr.ScVal.scvBytes(keyIdBuffer), SorobanRpc.Durability.Temporary)
+                    // throw true
+                } catch {
+                    this.keyExpired = true
+                }
+            }
         }
 
+        if (!contractId)
+            throw new Error('No `contractId` was found')
+
         this.wallet = new PasskeyClient({
             contractId,
             networkPassphrase: this.networkPassphrase,
             rpcUrl: this.rpcUrl
         })
 
-        // get and set the sudo signer (passing in `contractData` from the `getContractData` call above to avoid dupe requests)
-        await this.getData(contractData)
-
         return {
             keyId: keyIdBuffer,
             contractId
@@ -191,7 +187,7 @@ export class PasskeyKit extends PasskeyBase {
     public async signAuthEntry(
         entry: xdr.SorobanAuthorizationEntry,
         options?: {
-            keyId?: 'any' | 'sudo' | string | Uint8Array
+            keyId?: 'any' | string | Uint8Array
             ledgersToLive?: number
         }
     ) {
@@ -212,7 +208,6 @@ export class PasskeyKit extends PasskeyBase {
 
         const authenticationResponse = await startAuthentication(
             keyId === 'any'
-                || (keyId === 'sudo' && !this.sudoKeyId)
                 || (!keyId && !this.keyId)
                 ? {
                     challenge: base64url(payload),
@@ -224,11 +219,9 @@ export class PasskeyKit extends PasskeyBase {
                     // rpId: undefined,
                     allowCredentials: [
                         {
-                            id: keyId === 'sudo'
-                                ? this.sudoKeyId!
-                                : keyId instanceof Uint8Array
-                                    ? base64url(keyId)
-                                    : keyId || this.keyId!,
+                            id: keyId instanceof Uint8Array
+                                ? base64url(Buffer.from(keyId))
+                                : keyId || this.keyId!,
                             type: "public-key",
                         },
                     ],
@@ -236,9 +229,10 @@ export class PasskeyKit extends PasskeyBase {
                 }
         );
 
-        const signatureRaw = base64url.toBuffer(authenticationResponse.response.signature);
-        const signature = this.convertEcdsaSignatureAsnToCompact(signatureRaw);
-        
+        const signature = this.compactSignature(
+            base64url.toBuffer(authenticationResponse.response.signature)
+        );
+
         credentials.signatureExpirationLedger(lastLedger + ledgersToLive)
         credentials.signature(xdr.ScVal.scvMap([
             new xdr.ScMapEntry({
@@ -258,13 +252,13 @@ export class PasskeyKit extends PasskeyBase {
                 val: xdr.ScVal.scvBytes(signature),
             }),
         ]))
-        
+
         return entry
     }
     public async signAuthEntries(
         entries: xdr.SorobanAuthorizationEntry[],
         options?: {
-            keyId?: 'any' | 'sudo' | string | Uint8Array
+            keyId?: 'any' | string | Uint8Array
             ledgersToLive?: number
         }
     ) {
@@ -281,21 +275,14 @@ export class PasskeyKit extends PasskeyBase {
 
         return entries
     }
-    /* NOTE 
-        - Is there anything to be done with using the TS bindings `signAuthEntries` logic? Likely not but worth exploring 
-            Perhaps not but maybe the js-sdk's `authorizeEntry` or `authorizeInvocation`
-            https://stellar.github.io/js-stellar-sdk/global.html#authorizeInvocation
-            These methods all only support ed25519 Keypairs
-            @No
-    */
     public async sign(
         txn: Transaction | string,
         options?: {
-            keyId?: 'any' | 'sudo' | string | Uint8Array
+            keyId?: 'any' | string | Uint8Array
             ledgersToLive?: number
         }
     ) {
-        /* NOTE 
+        /*
             - Hack to ensure we don't stack fees when simulating and assembling multiple times
                 AssembleTransaction always adds the resource fee onto the transaction fee. 
                 This is bad in cases where you need to simulate multiple times
@@ -315,7 +302,7 @@ export class PasskeyKit extends PasskeyBase {
                 op.type !== 'invokeHostFunction'
                 && op.type !== 'extendFootprintTtl'
                 && op.type !== 'restoreFootprint'
-            ) throw new Error('Must include only one operation of type `invokeHostFunction` or `extendFootprintTtl` or `restoreFootprint`')    
+            ) throw new Error('Must include only one operation of type `invokeHostFunction` or `extendFootprintTtl` or `restoreFootprint`')
         }
 
         // Only need to sign auth for `invokeHostFunction` operations
@@ -336,167 +323,72 @@ export class PasskeyKit extends PasskeyBase {
         return SorobanRpc.assembleTransaction(txn, sim).build().toXDR()
     }
 
-    public async getData(contractData?: SorobanRpc.Api.LedgerEntryResult) {
-        const data: Map<string, any> = new Map()
-
-        /* TODO 
-            - Pretty easy to get into a state where there is no contractId and this we error at `this.wallet!.options.contractId,`
-                We should have a better error or maybe just handle no-wallet scenarios more gracefully
-        */
-        const { val } = contractData || await this.rpc.getContractData(
-            this.wallet!.options.contractId,
-            xdr.ScVal.scvLedgerKeyContractInstance(),
-        );
-
-        val.contractData()
-            .val()
-            .instance()
-            .storage()
-            ?.forEach((entry) => {
-                data.set(
-                    scValToNative(entry.key()),
-                    scValToNative(entry.val()),
-                );
-            });
-
-        this.sudoKeyId = base64url(data.get('sudo_sig'))
-
-        return data
-    }
-
     /* TODO 
         - Add a getKeyInfo action to get info about a specific passkey
             Specifically looking for name, type, etc. data so a user could grok what signer mapped to what passkey
             @Later
     */
 
-    private getPublicKeyObject(attestationObject: string) {
-        const { authData } = decode(base64url.toBuffer(attestationObject));
-        const authDataUint8Array = new Uint8Array(authData);
-        const authDataView = new DataView(authDataUint8Array.buffer, 0, authDataUint8Array.length);
-
-        let offset = 0;
-
-        // RP ID Hash (32 bytes)
-        const rpIdHash = authData.slice(offset, offset + 32);
-        offset += 32;
-
-        // Flags (1 byte)
-        const flags = authDataView.getUint8(offset);
-        offset += 1;
-
-        // Sign Count (4 bytes, big endian)
-        const signCount = authDataView.getUint32(offset, false);
-        offset += 4;
-
-        // Attested Credential Data, if present
-        if (flags & 0x40) { // Checking the AT flag
-            // AAGUID (16 bytes)
-            const aaguid = authData.slice(offset, offset + 16);
-            offset += 16;
-
-            // Credential ID Length (2 bytes, big endian)
-            const credIdLength = authDataView.getUint16(offset, false);
-            offset += 2;
-
-            // Credential ID (variable length)
-            const credentialId = authData.slice(offset, offset + credIdLength);
-            offset += credIdLength;
-
-            // Credential Public Key - (77 bytes...I hope)
-            const credentialPublicKey = authData.slice(offset, offset + 77);
-            offset += 77;
-
-            // Any leftover bytes. I found some when using a YubiKey
-            const theRest = authData.slice(offset);
-
-            // Decode the credential public key to COSE
-            const publicKeyObject = new Map<string, any>(Object.entries(decode(credentialPublicKey)));
-
-            return {
-                rpIdHash,
-                flags,
-                signCount,
-                aaguid,
-                credIdLength,
-                credentialId,
-                credentialPublicKey,
-                theRest,
-                publicKeyObject
-            };
-        }
-
-        throw new Error("Attested credential data not present in the flags.");
-    }
-
-    private convertEcdsaSignatureAsnToCompact(sig: Buffer) {
-        // Define the order of the curve secp256k1
-        // https://github.com/RustCrypto/elliptic-curves/blob/master/p256/src/lib.rs#L72
-        const q = Buffer.from('ffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551', 'hex')
-
-        // ASN Sequence
-        let offset = 0;
-        if (sig[offset] != 0x30) {
-            throw "signature is not a sequence";
-        }
-        offset += 1;
+    private getPublicKey(response: AuthenticatorAttestationResponseJSON) {
+        let publicKey: Buffer | undefined
 
-        // ASN Sequence Byte Length
-        offset += 1;
+        if (response.publicKey)
+            publicKey = base64url.toBuffer(response.publicKey).slice(response.publicKey.length - 65)
 
-        // ASN Integer (R)
-        if (sig[offset] != 0x02) {
-            throw "first element in sequence is not an integer";
+        if (
+            !publicKey
+            || publicKey[0] !== 0x04
+            || publicKey.length !== 65
+        ) {
+            // Extract and decode attestation object (CBOR), slice authenticator data to get COSE-encoded public key, and decode COSE to obtain key components
+            const { authData } = response.authenticatorData ? { authData: base64url.toBuffer(response.authenticatorData) } : decode(base64url.toBuffer(response.attestationObject));
+            const credentialIdLength = (authData[53] << 8) + authData[54];
+            const publicKeyBytes = authData.slice(55 + credentialIdLength);
+            const publicKeyCose = decode(publicKeyBytes);
+
+            publicKey = Buffer.from([
+                0x04, // (0x04 prefix) https://en.bitcoin.it/wiki/Elliptic_Curve_Digital_Signature_Algorithm
+                ...publicKeyCose['-2'],
+                ...publicKeyCose['-3']
+            ])
         }
-        offset += 1;
 
-        // ASN Integer (R) Byte Length
-        const rLen = sig[offset];
-        offset += 1;
+        return publicKey
+    }
+    private compactSignature(signature: Buffer) {
+        // Decode the DER signature
+        let offset = 2;
 
-        // ASN Integer (R) Byte Value
-        if (rLen >= 33) {
-            if (rLen != 33 || sig[offset] != 0x00) {
-                throw "can only handle larger than 32 byte R's that are len 33 and lead with zero";
-            }
-            offset += 1;
-        }
-        const r = sig.slice(offset, offset + 32);
-        offset += 32;
+        const rLength = signature[offset + 1];
+        const r = signature.slice(offset + 2, offset + 2 + rLength);
 
-        // ASN Integer (S)
-        if (sig[offset] != 0x02) {
-            throw "second element in sequence is not an integer";
-        }
-        offset += 1;
+        offset += 2 + rLength;
 
-        // ASN Integer (S) Byte Length
-        const sLen = sig[offset];
-        offset += 1;
+        const sLength = signature[offset + 1];
+        const s = signature.slice(offset + 2, offset + 2 + sLength);
 
-        // ASN Integer (S) Byte Value
-        if (sLen >= 33) {
-            if (sLen != 33 || sig[offset] != 0x00) {
-                throw "can only handle larger than 32 byte R's that are len 33 and lead with zero";
-            }
-            offset += 1;
-        }
+        // Convert r and s to BigInt
+        const rBigInt = BigInt('0x' + r.toString('hex'));
+        let sBigInt = BigInt('0x' + s.toString('hex'));
 
-        const s = sig.slice(offset, offset + 32);
+        // Ensure s is in the low-S form
+        // https://github.com/stellar/stellar-protocol/discussions/1435#discussioncomment-8809175
+        // https://discord.com/channels/897514728459468821/1233048618571927693
+        // Define the order of the curve secp256r1
+        // https://github.com/RustCrypto/elliptic-curves/blob/master/p256/src/lib.rs#L72
+        const n = BigInt('0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551');
+        const halfN = n / 2n;
 
-        offset += 32;
+        if (sBigInt > halfN)
+            sBigInt = n - sBigInt;
 
-        let signature64: Buffer
+        // Convert back to buffers and ensure they are 32 bytes
+        const rPadded = Buffer.from(rBigInt.toString(16).padStart(64, '0'), 'hex');
+        const sLowS = Buffer.from(sBigInt.toString(16).padStart(64, '0'), 'hex');
 
-        // Force low S range
-        // https://github.com/stellar/stellar-protocol/discussions/1435#discussioncomment-8809175
-        // https://discord.com/channels/897514728459468821/1233048618571927693
-        if (bufToBigint(s) > ((bufToBigint(q) - BigInt(1)) / BigInt(2))) {
-            signature64 = Buffer.from([...r, ...Buffer.from(bigintToBuf(bufToBigint(q) - bufToBigint(s), true) as ArrayBuffer)]);
-        } else {
-            signature64 = Buffer.from([...r, ...s]);
-        }
+        // Concatenate r and low-s
+        const concatSignature = Buffer.concat([rPadded, sLowS]);
 
-        return signature64;
+        return concatSignature;
     }
 }

package/tsconfig.json

@@ -6,7 +6,6 @@
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",
-    // "allowJs": true,
 
     // Bundler mode
     "moduleResolution": "node",
@@ -26,5 +25,5 @@
     "noPropertyAccessFromIndexSignature": false,
     "strictNullChecks": true,
   },
-  "exclude": ["./demo", "./packages", "./types", "./contracts"]
+  "exclude": ["./demo", "./packages", "./types", "./contracts", "./zephyr", "./bun_tests"]
 }

package/types/kit.d.ts

@@ -3,48 +3,51 @@ import { Client as FactoryClient } from 'passkey-factory-sdk';
 import { Networks, xdr, Transaction, SorobanRpc } from '@stellar/stellar-sdk';
 import { Buffer } from 'buffer';
 import { PasskeyBase } from './base';
+type GetContractIdFunction = (keyId: string) => Promise<string>;
 export declare class PasskeyKit extends PasskeyBase {
     keyId: string | undefined;
-    sudoKeyId: string | undefined;
+    keyExpired: boolean | undefined;
     wallet: PasskeyClient | undefined;
     factory: FactoryClient;
     networkPassphrase: Networks;
     rpcUrl: string;
     rpc: SorobanRpc.Server;
-    factoryContractId: string;
     constructor(options: {
         rpcUrl: string;
         launchtubeUrl?: string;
         launchtubeJwt?: string;
-        factoryContractId?: string;
         networkPassphrase: string;
+        factoryContractId: string;
     });
-    createWallet(name: string, user: string): Promise<{
+    createWallet(app: string, user: string): Promise<{
         keyId: Buffer;
         contractId: string;
         xdr: string;
     }>;
-    createKey(name: string, user: string): Promise<{
+    createKey(app: string, user: string): Promise<{
         keyId: Buffer;
         publicKey: Buffer;
     }>;
-    connectWallet(keyId?: string): Promise<{
+    connectWallet(opts: {
+        keyId?: string | Uint8Array;
+        getContractId?: GetContractIdFunction;
+    }): Promise<{
         keyId: Buffer;
         contractId: string;
     }>;
     signAuthEntry(entry: xdr.SorobanAuthorizationEntry, options?: {
-        keyId?: 'any' | 'sudo' | string | Uint8Array;
+        keyId?: 'any' | string | Uint8Array;
         ledgersToLive?: number;
     }): Promise<xdr.SorobanAuthorizationEntry>;
     signAuthEntries(entries: xdr.SorobanAuthorizationEntry[], options?: {
-        keyId?: 'any' | 'sudo' | string | Uint8Array;
+        keyId?: 'any' | string | Uint8Array;
         ledgersToLive?: number;
     }): Promise<xdr.SorobanAuthorizationEntry[]>;
     sign(txn: Transaction | string, options?: {
-        keyId?: 'any' | 'sudo' | string | Uint8Array;
+        keyId?: 'any' | string | Uint8Array;
         ledgersToLive?: number;
     }): Promise<string>;
-    getData(contractData?: SorobanRpc.Api.LedgerEntryResult): Promise<Map<string, any>>;
-    private getPublicKeyObject;
-    private convertEcdsaSignatureAsnToCompact;
+    private getPublicKey;
+    private compactSignature;
 }
+export {};

package/types/src/base.d.ts

@@ -0,0 +1,9 @@
+export declare class PasskeyBase {
+    launchtubeUrl: string | undefined;
+    launchtubeJwt: string | undefined;
+    constructor(options: {
+        launchtubeUrl?: string;
+        launchtubeJwt?: string;
+    });
+    send(xdr: string, fee?: number): Promise<any>;
+}

package/types/src/index.d.ts

@@ -0,0 +1,3 @@
+import { PasskeyBase } from "./base";
+import { PasskeyKit } from "./kit";
+export { PasskeyBase, PasskeyKit };