passkey-kit 0.7.11 → 0.7.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "passkey-kit",
-  "version": "0.7.11",
+  "version": "0.7.13",
   "description": "A helper library for creating and using passkey accounts on the Stellar blockchain.",
   "author": "Tyler van der Hoeven",
   "license": "MIT",
@@ -13,8 +13,8 @@
     "@stellar/stellar-sdk": "file:./ext/@stellar/stellar-sdk",
     "base64url": "^3.0.1",
     "buffer": "^6.0.3",
-    "passkey-kit-sdk": "0.3.4",
     "passkey-factory-sdk": "0.3.4",
+    "passkey-kit-sdk": "0.3.4",
     "sac-sdk": "0.1.1"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,5 +1,5 @@
 import { PasskeyServer } from "./server"
-import { PasskeyKit } from "./kit"
+import { PasskeyKit, SignerStore, SignerKey, type SignerLimits } from "./kit"
 import { SACClient } from "./sac"
 
-export { PasskeyServer, PasskeyKit, SACClient }
+export { PasskeyServer, PasskeyKit, SACClient, SignerStore, SignerKey, type SignerLimits }

package/src/kit.ts

@@ -1,12 +1,35 @@
-import { Client as PasskeyClient, type Signature, type Signatures, type SignerKey } from 'passkey-kit-sdk'
+import { Client as PasskeyClient, type Signature, type SignerKey as SDKSignerKey, type SignerLimits as SDKSignerLimits } from 'passkey-kit-sdk'
 import { Client as FactoryClient } from 'passkey-factory-sdk'
-import { Address, StrKey, hash, xdr, SorobanRpc, Keypair, Transaction, Operation, nativeToScVal } from '@stellar/stellar-sdk'
+import { StrKey, hash, xdr, SorobanRpc, Keypair, Address } from '@stellar/stellar-sdk'
 import base64url from 'base64url'
 import { startRegistration, startAuthentication } from "@simplewebauthn/browser"
 import type { AuthenticatorAttestationResponseJSON, AuthenticatorSelectionCriteria } from "@simplewebauthn/types"
 import { Buffer } from 'buffer'
 import { PasskeyBase } from './base'
-import { AssembledTransaction, DEFAULT_TIMEOUT, type Tx } from '@stellar/stellar-sdk/contract'
+import { AssembledTransaction, DEFAULT_TIMEOUT } from '@stellar/stellar-sdk/contract'
+
+export class SignerKey {
+    private constructor(public key: "Policy" | "Ed25519" | "Secp256r1", public value: string) { }
+
+    static Policy(policy: string): SignerKey {
+        return new SignerKey("Policy", policy);
+    }
+
+    static Ed25519(publicKey: string): SignerKey {
+        return new SignerKey("Ed25519", publicKey);
+    }
+
+    static Secp256r1(id: string): SignerKey {
+        return new SignerKey("Secp256r1", id);
+    }
+}
+
+export type SignerLimits = Map<string, SignerKey[] | undefined>
+
+export enum SignerStore {
+    Persistent = 'Persistent',
+    Temporary = 'Temporary',
+}
 
 export class PasskeyKit extends PasskeyBase {
     declare public rpc: SorobanRpc.Server
@@ -219,7 +242,7 @@ export class PasskeyKit extends PasskeyBase {
         const payload = hash(preimage.toXDR())
 
         // let signatures: Signatures
-        let key: SignerKey
+        let key: SDKSignerKey
         let val: Signature | undefined
 
         // const scSpecTypeDefSignatures = xdr.ScSpecTypeDef.scSpecTypeUdt(
@@ -367,7 +390,7 @@ export class PasskeyKit extends PasskeyBase {
         return entry
     }
 
-    public async sign<T>(
+    public sign<T>(
         txn: AssembledTransaction<T>,
         options?: {
             rpId?: string,
@@ -377,22 +400,115 @@ export class PasskeyKit extends PasskeyBase {
             expiration?: number
         }
     ) {
-        await txn.signAuthEntries({
+        // TODO ensure we're outputting a built transaction that's actually useful in the case you don't intend to use launchtube
+        // Pretty sure we'll always be woefully under budget
+        return txn.signAuthEntries({
             address: this.wallet!.options.contractId,
             authorizeEntry: (entry) => {
                 const clone = xdr.SorobanAuthorizationEntry.fromXDR(entry.toXDR())
-                return this.signAuthEntry(clone, options)    
+                return this.signAuthEntry(clone, options)
             },
         })
     }
 
-    // Add little utility helpers for adding and removing signers
+    public addSecp256r1(keyId: Uint8Array, publicKey: Uint8Array, limits: SignerLimits, store: SignerStore) {
+        return this.wallet!.add({
+            signer: {
+                tag: "Secp256r1",
+                values: [
+                    Buffer.from(keyId),
+                    Buffer.from(publicKey),
+                    this.getSignerLimits(limits),
+                    { tag: store, values: undefined },
+                ],
+            },
+        });
+    }
+    public addEd25519(publicKey: string, limits: SignerLimits, store: SignerStore) {
+        return this.wallet!.add({
+            signer: {
+                tag: "Ed25519",
+                values: [
+                    Keypair.fromPublicKey(publicKey).rawPublicKey(),
+                    this.getSignerLimits(limits),
+                    { tag: store, values: undefined },
+                ],
+            },
+        });
+    }
+    public addPolicy(policy: string, limits: SignerLimits, store: SignerStore) {
+        return this.wallet!.add({
+            signer: {
+                tag: "Policy",
+                values: [
+                    policy,
+                    this.getSignerLimits(limits),
+                    { tag: store, values: undefined },
+                ],
+            },
+        });
+    }
+
+    public remove(signer: SignerKey) {
+        return this.wallet!.remove({
+            signer_key: this.getSignerKey(signer)
+        });
+    }
 
     /* LATER 
         - 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
     */
 
+    private getSignerLimits(limits: SignerLimits) {
+        const sdk_limits: SDKSignerLimits = [new Map()]
+
+        for (const [contract, signer_keys] of limits.entries()) {
+            let sdk_signer_keys: SDKSignerKey[] | undefined
+
+            if (signer_keys?.length) {
+                sdk_signer_keys = []
+
+                for (const signer_key of signer_keys) {
+                    sdk_signer_keys.push(
+                        this.getSignerKey(signer_key)
+                    )
+                }
+            }
+
+            sdk_limits[0].set(contract, sdk_signer_keys)
+        }
+
+        return sdk_limits
+    }
+
+    private getSignerKey({ key: tag, value }: SignerKey) {
+        let signer_key: SDKSignerKey
+
+        switch (tag) {
+            case 'Policy':
+                signer_key = {
+                    tag,
+                    values: [value]
+                }
+                break;
+            case 'Ed25519':
+                signer_key = {
+                    tag,
+                    values: [Keypair.fromPublicKey(value).rawPublicKey()]
+                }
+                break;
+            case 'Secp256r1':
+                signer_key = {
+                    tag,
+                    values: [base64url.toBuffer(value)]
+                }
+                break;
+        }
+
+        return signer_key
+    }
+
     private async getPublicKey(response: AuthenticatorAttestationResponseJSON) {
         let publicKey: Buffer | undefined
 

package/types/index.d.ts

@@ -1,4 +1,4 @@
 import { PasskeyServer } from "./server";
-import { PasskeyKit } from "./kit";
+import { PasskeyKit, SignerStore, SignerKey, type SignerLimits } from "./kit";
 import { SACClient } from "./sac";
-export { PasskeyServer, PasskeyKit, SACClient };
+export { PasskeyServer, PasskeyKit, SACClient, SignerStore, SignerKey, type SignerLimits };

package/types/kit.d.ts

@@ -5,7 +5,20 @@ import { startRegistration, startAuthentication } from "@simplewebauthn/browser"
 import type { AuthenticatorSelectionCriteria } from "@simplewebauthn/types";
 import { Buffer } from 'buffer';
 import { PasskeyBase } from './base';
-import { AssembledTransaction, type Tx } from '@stellar/stellar-sdk/contract';
+import { AssembledTransaction } from '@stellar/stellar-sdk/contract';
+export declare class SignerKey {
+    key: "Policy" | "Ed25519" | "Secp256r1";
+    value: string;
+    private constructor();
+    static Policy(policy: string): SignerKey;
+    static Ed25519(publicKey: string): SignerKey;
+    static Secp256r1(id: string): SignerKey;
+}
+export type SignerLimits = Map<string, SignerKey[] | undefined>;
+export declare enum SignerStore {
+    Persistent = "Persistent",
+    Temporary = "Temporary"
+}
 export declare class PasskeyKit extends PasskeyBase {
     rpc: SorobanRpc.Server;
     rpcUrl: string;
@@ -29,7 +42,7 @@ export declare class PasskeyKit extends PasskeyBase {
     createWallet(app: string, user: string): Promise<{
         keyId: Buffer;
         contractId: string;
-        built: Tx;
+        built: import("@stellar/stellar-sdk/contract").Tx;
     }>;
     createKey(app: string, user: string, settings?: {
         rpId?: string;
@@ -60,6 +73,12 @@ export declare class PasskeyKit extends PasskeyBase {
         policy?: string;
         expiration?: number;
     }): Promise<void>;
+    addSecp256r1(keyId: Uint8Array, publicKey: Uint8Array, limits: SignerLimits, store: SignerStore): Promise<AssembledTransaction<import("@stellar/stellar-sdk/contract").Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>>;
+    addEd25519(publicKey: string, limits: SignerLimits, store: SignerStore): Promise<AssembledTransaction<import("@stellar/stellar-sdk/contract").Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>>;
+    addPolicy(policy: string, limits: SignerLimits, store: SignerStore): Promise<AssembledTransaction<import("@stellar/stellar-sdk/contract").Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>>;
+    remove(signer: SignerKey): Promise<AssembledTransaction<import("@stellar/stellar-sdk/contract").Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>>;
+    private getSignerLimits;
+    private getSignerKey;
     private getPublicKey;
     private compactSignature;
 }