passkey-kit 0.10.15 → 0.10.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "passkey-kit",
-  "version": "0.10.15",
+  "version": "0.10.17",
   "description": "A helper library for creating and using smart wallet accounts on the Stellar blockchain.",
   "author": "Tyler van der Hoeven",
   "license": "MIT",

package/src/kit.ts

@@ -136,7 +136,7 @@ export class PasskeyKit extends PasskeyBase {
         rpId?: string,
         keyId?: string | Uint8Array,
         getContractId?: (keyId: string) => Promise<string | undefined>,
-        walletPublicKey?: string // TEMP for backwards compatibility when we seeded wallets from a factory address
+        walletPublicKey?: string // TEMP for backwards compatibility for when we seeded wallets from a factory address
     }) {
         let { keyId, rpId, getContractId, walletPublicKey } = opts || {}
         let keyIdBuffer: Buffer
@@ -164,17 +164,7 @@ export class PasskeyKit extends PasskeyBase {
             this.keyId = keyId
 
         // 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)),
-                contractIdPreimage: xdr.ContractIdPreimage.contractIdPreimageFromAddress(
-                    new xdr.ContractIdPreimageFromAddress({
-                        address: Address.fromString(walletPublicKey || this.walletPublicKey).toScAddress(),
-                        salt: hash(keyIdBuffer),
-                    })
-                )
-            })
-        ).toXDR()));
+        let contractId: string | undefined = this.encodeContract(this.walletPublicKey, keyIdBuffer);
 
         // attempt passkey id derivation
         try {
@@ -186,6 +176,19 @@ export class PasskeyKit extends PasskeyBase {
             contractId = getContractId && await getContractId(keyId)
         }
 
+        ////
+        // TEMP for backwards compatibility for when we seeded wallets from a factory address
+        if (!contractId && walletPublicKey) {
+            contractId = this.encodeContract(walletPublicKey, keyIdBuffer);
+
+            try {
+                await this.rpc.getContractData(contractId, xdr.ScVal.scvLedgerKeyContractInstance())
+            } catch {
+                contractId = undefined
+            }
+        }
+        ////
+
         if (!contractId)
             throw new Error('Failed to connect wallet')
 
@@ -556,6 +559,22 @@ export class PasskeyKit extends PasskeyBase {
         return signer_key
     }
 
+    private encodeContract(walletPublicKey: string, keyIdBuffer: Buffer) {
+        let contractId: string | undefined = StrKey.encodeContract(hash(xdr.HashIdPreimage.envelopeTypeContractId(
+            new xdr.HashIdPreimageContractId({
+                networkId: hash(Buffer.from(this.networkPassphrase)),
+                contractIdPreimage: xdr.ContractIdPreimage.contractIdPreimageFromAddress(
+                    new xdr.ContractIdPreimageFromAddress({
+                        address: Address.fromString(walletPublicKey).toScAddress(),
+                        salt: hash(keyIdBuffer),
+                    })
+                )
+            })
+        ).toXDR()));
+
+        return contractId
+    }
+
     private async getPublicKey(response: AuthenticatorAttestationResponseJSON) {
         let publicKey: Buffer | undefined
 

package/src/server.ts

@@ -1,10 +1,11 @@
-import { Transaction, xdr, Networks, Operation } from "@stellar/stellar-sdk/minimal"
+import { xdr } from "@stellar/stellar-sdk/minimal"
 import { PasskeyBase } from "./base"
 import base64url from "base64url"
 import type { Tx } from "@stellar/stellar-sdk/minimal/contract"
 import type { Signer } from "./types"
 import { AssembledTransaction } from "@stellar/stellar-sdk/minimal/contract"
 import { Durability } from "@stellar/stellar-sdk/minimal/rpc"
+import { version } from '../package.json'
 
 export class PasskeyServer extends PasskeyBase {
     private launchtubeJwt: string | undefined
@@ -149,7 +150,7 @@ export class PasskeyServer extends PasskeyBase {
         - Add a method for getting a paginated or filtered list of all a wallet's events
     */
 
-    public async send<T>(txn: AssembledTransaction<T> | Tx | string, fee?: number) {
+    public async send<T>(txn: AssembledTransaction<T> | Tx | string, fee?: number, headers?: Record<string, string>) {
         if (!this.launchtubeUrl || !this.launchtubeJwt)
             throw new Error('Launchtube service not configured')
 
@@ -170,11 +171,14 @@ export class PasskeyServer extends PasskeyBase {
             method: 'POST',
             headers: {
                 authorization: `Bearer ${this.launchtubeJwt}`,
+                'X-Client-Name': 'passkey-kit',
+                'X-Client-Version': version,
+                ...headers
             },
             body: data
         }).then(async (res) => {
             if (res.ok)
-                return res.json()
+            return res.json()
             else throw await res.json()
         })
     }

package/types/kit.d.ts

@@ -76,6 +76,7 @@ export declare class PasskeyKit extends PasskeyBase {
     private policy;
     private getSignerLimits;
     private getSignerKey;
+    private encodeContract;
     private getPublicKey;
     private compactSignature;
 }

package/types/src/base.d.ts

@@ -0,0 +1,6 @@
+import { Server } from "@stellar/stellar-sdk/minimal/rpc";
+export declare class PasskeyBase {
+    rpcUrl: string | undefined;
+    rpc: Server | undefined;
+    constructor(rpcUrl?: string);
+}

package/types/src/index.d.ts

@@ -0,0 +1,5 @@
+export { SignerStore, SignerKey, type Signer, type SignerLimits } from './types';
+export { PasskeyKit } from "./kit";
+export { PasskeyServer } from "./server";
+export { SACClient } from "./sac";
+export { Client as PasskeyClient } from 'passkey-kit-sdk';

package/types/src/kit.d.ts

@@ -0,0 +1,82 @@
+import { Client as PasskeyClient } from 'passkey-kit-sdk';
+import { xdr, Keypair } from '@stellar/stellar-sdk/minimal';
+import type { AuthenticatorSelectionCriteria } from "@simplewebauthn/types";
+import { startRegistration, startAuthentication } from "@simplewebauthn/browser";
+import { Buffer } from 'buffer';
+import type { SignerKey, SignerLimits, SignerStore } from './types';
+import { PasskeyBase } from './base';
+import { AssembledTransaction, type Tx } from '@stellar/stellar-sdk/minimal/contract';
+import type { Server } from '@stellar/stellar-sdk/minimal/rpc';
+export declare class PasskeyKit extends PasskeyBase {
+    rpc: Server;
+    rpcUrl: string;
+    private walletKeypair;
+    private walletPublicKey;
+    private walletWasmHash;
+    private WebAuthn;
+    keyId: string | undefined;
+    networkPassphrase: string;
+    wallet: PasskeyClient | undefined;
+    constructor(options: {
+        rpcUrl: string;
+        networkPassphrase: string;
+        walletWasmHash: string;
+        WebAuthn?: {
+            startRegistration: typeof startRegistration;
+            startAuthentication: typeof startAuthentication;
+        };
+    });
+    createWallet(app: string, user: string): Promise<{
+        keyId: Buffer<ArrayBufferLike>;
+        keyIdBase64: string;
+        contractId: string;
+        signedTx: Tx;
+    }>;
+    createKey(app: string, user: string, settings?: {
+        rpId?: string;
+        authenticatorSelection?: AuthenticatorSelectionCriteria;
+    }): Promise<{
+        keyId: Buffer<ArrayBufferLike>;
+        keyIdBase64: string;
+        publicKey: Buffer<ArrayBufferLike>;
+    }>;
+    connectWallet(opts?: {
+        rpId?: string;
+        keyId?: string | Uint8Array;
+        getContractId?: (keyId: string) => Promise<string | undefined>;
+        walletPublicKey?: string;
+    }): Promise<{
+        keyId: Buffer<ArrayBufferLike>;
+        keyIdBase64: string;
+        contractId: string;
+    }>;
+    signAuthEntry(entry: xdr.SorobanAuthorizationEntry, options?: {
+        rpId?: string;
+        keyId?: 'any' | string | Uint8Array;
+        keypair?: Keypair;
+        policy?: string;
+        expiration?: number;
+    }): Promise<xdr.SorobanAuthorizationEntry>;
+    sign<T>(txn: AssembledTransaction<T> | Tx | string, options?: {
+        rpId?: string;
+        keyId?: 'any' | string | Uint8Array;
+        keypair?: Keypair;
+        policy?: string;
+        expiration?: number;
+    }): Promise<AssembledTransaction<T>>;
+    addSecp256r1(keyId: string | Uint8Array, publicKey: string | Uint8Array, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    addEd25519(publicKey: string, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    addPolicy(policy: string, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    updateSecp256r1(keyId: string | Uint8Array, publicKey: string | Uint8Array, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    updateEd25519(publicKey: string, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    updatePolicy(policy: string, limits: SignerLimits, store: SignerStore, expiration?: number): Promise<AssembledTransaction<null>>;
+    remove(signer: SignerKey): Promise<AssembledTransaction<null>>;
+    private secp256r1;
+    private ed25519;
+    private policy;
+    private getSignerLimits;
+    private getSignerKey;
+    private encodeContract;
+    private getPublicKey;
+    private compactSignature;
+}

package/types/src/sac.d.ts

@@ -0,0 +1,13 @@
+import { Client as SacClient } from 'sac-sdk';
+import { PasskeyBase } from "./base";
+import type { Server } from '@stellar/stellar-sdk/minimal/rpc';
+export declare class SACClient extends PasskeyBase {
+    rpc: Server;
+    rpcUrl: string;
+    networkPassphrase: string;
+    constructor(options: {
+        networkPassphrase: string;
+        rpcUrl: string;
+    });
+    getSACClient(SACContractId: string): SacClient;
+}

package/types/src/server.d.ts

@@ -0,0 +1,28 @@
+import { PasskeyBase } from "./base";
+import type { Tx } from "@stellar/stellar-sdk/minimal/contract";
+import type { Signer } from "./types";
+import { AssembledTransaction } from "@stellar/stellar-sdk/minimal/contract";
+export declare class PasskeyServer extends PasskeyBase {
+    private launchtubeJwt;
+    private mercuryJwt;
+    private mercuryKey;
+    launchtubeUrl: string | undefined;
+    mercuryProjectName: string | undefined;
+    mercuryUrl: string | undefined;
+    constructor(options: {
+        rpcUrl?: string;
+        launchtubeUrl?: string;
+        launchtubeJwt?: string;
+        mercuryProjectName?: string;
+        mercuryUrl?: string;
+        mercuryJwt?: string;
+        mercuryKey?: string;
+    });
+    getSigners(contractId: string): Promise<Signer[]>;
+    getContractId(options: {
+        keyId?: string;
+        publicKey?: string;
+        policy?: string;
+    }, index?: number): Promise<string>;
+    send<T>(txn: AssembledTransaction<T> | Tx | string, fee?: number, headers?: Record<string, string>): Promise<any>;
+}

package/types/src/types.d.ts

@@ -0,0 +1,22 @@
+export type Signer = {
+    kind: string;
+    key: string;
+    val: string;
+    expiration: number | null;
+    storage: "Persistent" | "Temporary";
+    limits: string;
+    evicted?: boolean;
+};
+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> | undefined;
+export declare enum SignerStore {
+    Persistent = "Persistent",
+    Temporary = "Temporary"
+}