passkey-kit 0.4.6 → 0.5.1

package/src/base.ts

@@ -1,189 +1,13 @@
-import { SorobanRpc, xdr } from "@stellar/stellar-sdk"
-import base64url from "base64url"
+import { SorobanRpc } from "@stellar/stellar-sdk"
 
 export class PasskeyBase {
-    public rpc: SorobanRpc.Server | undefined
     public rpcUrl: string | undefined
-    public launchtubeUrl: string | undefined
-    public launchtubeJwt: string | undefined
-    public mercuryUrl: string | undefined
-    public mercuryJwt: string | undefined
-    public mercuryEmail: string | undefined
-    public mercuryPassword: string | undefined
-
-    constructor(options: {
-        rpcUrl?: string,
-        launchtubeUrl?: string,
-        launchtubeJwt?: string,
-        mercuryUrl?: string,
-        mercuryJwt?: string,
-        mercuryEmail?: string,
-        mercuryPassword?: string
-    }) {
-        const {
-            rpcUrl,
-            launchtubeUrl,
-            launchtubeJwt,
-            mercuryUrl,
-            mercuryJwt,
-            mercuryEmail,
-            mercuryPassword
-        } = options
-
-        if (launchtubeUrl)
-            this.launchtubeUrl = launchtubeUrl
-
-        if (launchtubeJwt)
-            this.launchtubeJwt = launchtubeJwt
-
-        if (mercuryUrl)
-            this.mercuryUrl = mercuryUrl
-
-        if (mercuryJwt)
-            this.mercuryJwt = mercuryJwt
-
-        if (mercuryEmail)
-            this.mercuryEmail = mercuryEmail
-
-        if (mercuryPassword)
-            this.mercuryPassword = mercuryPassword
-
+    public rpc: SorobanRpc.Server | undefined
+    
+    constructor(rpcUrl?: string) {
         if (rpcUrl) {
             this.rpcUrl = rpcUrl
             this.rpc = new SorobanRpc.Server(rpcUrl)
         }
     }
-
-    public async setMercuryJwt() {
-        if (!this.mercuryUrl || !this.mercuryEmail || !this.mercuryPassword)
-            throw new Error('Mercury service not configured')
-
-        const { data: { authenticate: { jwtToken } } } = await fetch(`${this.mercuryUrl}/graphql`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            body: JSON.stringify({
-                query: `mutation {
-                    authenticate(input: {
-                        email: "${this.mercuryEmail}"
-                        password: "${this.mercuryPassword}"
-                    }) {
-                        jwtToken
-                    }
-                }`
-            })
-        })
-            .then(async (res) => {
-                if (res.ok)
-                    return res.json()
-
-                throw await res.json()
-            })
-
-        this.mercuryJwt = jwtToken
-        return jwtToken
-    }
-
-    public async getSigners(contractId: string) {
-        if (!this.rpc || !this.mercuryUrl || !this.mercuryJwt)
-            throw new Error('Mercury service not configured')
-
-        const signers = await fetch(`${this.mercuryUrl}/zephyr/execute`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.mercuryJwt}`
-            },
-            body: JSON.stringify({
-                mode: {
-                    Function: {
-                        fname: "get_signers_by_address",
-                        arguments: JSON.stringify({
-                            address: contractId
-                        })
-                    }
-                }
-            })
-        })
-            .then(async (res) => {
-                if (res.ok)
-                    return res.json()
-
-                throw await res.json()
-            })
-
-        for (const signer of signers) {
-            if (!signer.admin) {
-                try {
-                    await this.rpc.getContractData(contractId, xdr.ScVal.scvBytes(signer.id), SorobanRpc.Durability.Temporary)
-                } catch {
-                    signer.expired = true
-                }
-            }
-
-            signer.id = base64url(signer.id)
-            signer.pk = base64url(signer.pk)
-        }
-
-        return signers as { id: string, pk: string, admin: boolean, expired?: boolean }[]
-    }
-
-    public async getContractId(keyId: string) {
-        if (!this.mercuryUrl || !this.mercuryJwt)
-            return
-
-        const res = await fetch(`${this.mercuryUrl}/zephyr/execute`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${this.mercuryJwt}`
-            },
-            body: JSON.stringify({
-                mode: {
-                    Function: {
-                        fname: "get_address_by_signer",
-                        arguments: JSON.stringify({
-                            id: [...base64url.toBuffer(keyId)]
-                        })
-                    }
-                }
-            })
-        })
-            .then(async (res) => {
-                if (res.ok)
-                    return res.json()
-
-                throw await res.json()
-            })
-
-        return res[0]?.address as string | undefined
-    }
-
-    /* TODO 
-        - Add a method for getting a paginated or filtered list of all a wallet's events
-            @Later
-    */
-
-    public async send(xdr: string, fee: number = 10_000) {
-        if (!this.launchtubeUrl || !this.launchtubeJwt)
-            throw new Error('Launchtube service not configured')
-
-        const data = new FormData();
-
-        data.set('xdr', xdr);
-        data.set('fee', fee.toString());
-
-        return fetch(this.launchtubeUrl, {
-            method: 'POST',
-            headers: {
-                authorization: `Bearer ${this.launchtubeJwt}`,
-            },
-            body: data
-        }).then(async (res) => {
-            if (res.ok)
-                return res.json()
-            else throw await res.json()
-        })
-    }
 }

package/src/index.ts

@@ -1,4 +1,5 @@
-import { PasskeyBase } from "./base"
+import { PasskeyServer } from "./server"
 import { PasskeyKit } from "./kit"
+import { SACClient } from "./sac"
 
-export { PasskeyBase, PasskeyKit }
+export { PasskeyServer, PasskeyKit, SACClient }

package/src/kit.ts

@@ -8,6 +8,8 @@ import { Buffer } from 'buffer'
 import { PasskeyBase } from './base'
 
 export class PasskeyKit extends PasskeyBase {
+    declare public rpc: SorobanRpc.Server
+    declare public rpcUrl: string
     public keyId: string | undefined
     public networkPassphrase: string
     public factory: FactoryClient
@@ -17,22 +19,10 @@ export class PasskeyKit extends PasskeyBase {
         rpcUrl: string,
         networkPassphrase: string,
         factoryContractId: string,
-        launchtubeUrl?: string,
-        launchtubeJwt?: string,
-        mercuryUrl?: string,
-        mercuryJwt?: string,
-        mercuryEmail?: string,
-        mercuryPassword?: string
     }) {
         const { rpcUrl, networkPassphrase, factoryContractId } = options
 
-        super(options)
-
-        if (!this.rpcUrl)
-            this.rpcUrl = rpcUrl
-
-        if (!this.rpc)
-            this.rpc = new SorobanRpc.Server(rpcUrl)
+        super(rpcUrl)
 
         this.networkPassphrase = networkPassphrase
         this.factory = new FactoryClient({
@@ -103,7 +93,7 @@ export class PasskeyKit extends PasskeyBase {
         keyId?: string | Uint8Array,
         getContractId?: (keyId: string) => Promise<string | undefined>
     }) {
-        let { keyId, getContractId = this.getContractId } = opts || {}
+        let { keyId, getContractId } = opts || {}
         let keyIdBuffer: Buffer
 
         if (!keyId) {
@@ -114,8 +104,6 @@ export class PasskeyKit extends PasskeyBase {
                 timeout: 120_000
             });
 
-            // console.log(response);
-
             keyId = response.id
         }
 
@@ -145,11 +133,11 @@ export class PasskeyKit extends PasskeyBase {
         // attempt passkey id derivation
         try {
             // TODO what is the error if the entry exists but is archived?
-            await this.rpc!.getContractData(contractId, xdr.ScVal.scvLedgerKeyContractInstance())
+            await this.rpc.getContractData(contractId, xdr.ScVal.scvLedgerKeyContractInstance())
         }
         // if that fails look up from the `getContractId` function
         catch {
-            contractId = await getContractId(keyId)
+            contractId = getContractId ? await getContractId(keyId) : undefined
         }
 
         if (!contractId)
@@ -177,7 +165,7 @@ export class PasskeyKit extends PasskeyBase {
         // Default mirrors DEFAULT_TIMEOUT (currently 5 minutes) https://github.com/stellar/js-stellar-sdk/blob/master/src/contract/utils.ts#L7
         let { keyId, ledgersToLive = 60 } = options || {}
 
-        const lastLedger = await this.rpc!.getLatestLedger().then(({ sequence }) => sequence)
+        const lastLedger = await this.rpc.getLatestLedger().then(({ sequence }) => sequence)
         const credentials = entry.credentials().address();
         const preimage = xdr.HashIdPreimage.envelopeTypeSorobanAuthorization(
             new xdr.HashIdPreimageSorobanAuthorization({
@@ -300,7 +288,7 @@ export class PasskeyKit extends PasskeyBase {
                 await this.signAuthEntries(entries, options)
         }
 
-        const sim = await this.rpc!.simulateTransaction(txn)
+        const sim = await this.rpc.simulateTransaction(txn)
 
         if (
             SorobanRpc.Api.isSimulationError(sim)

package/src/sac.ts

@@ -0,0 +1,94 @@
+import { SorobanRpc } from "@stellar/stellar-sdk"
+import { Client as SacClient } from 'sac-sdk'
+
+export class SACClient {
+    public networkPassphrase: string
+    public rpcUrl: string
+    public rpc: SorobanRpc.Server
+    
+    constructor(options: {
+        networkPassphrase: string,
+        rpcUrl: string
+    }) {
+        const { networkPassphrase, rpcUrl } = options
+
+        this.networkPassphrase = networkPassphrase
+        this.rpcUrl = rpcUrl
+        this.rpc = new SorobanRpc.Server(rpcUrl)
+    }
+
+    public getSACClient(SACContractId: string) {
+        return new SacClient({
+            contractId: SACContractId,
+            networkPassphrase: this.networkPassphrase,
+            rpcUrl: this.rpcUrl
+        })
+
+        // switch (command) {
+        //     case SacCommands.Allowance:
+        //         return sac.allowance(args)
+        //     case SacCommands.Authorized:
+        //         return sac.authorized(args)
+        //     case SacCommands.Approve:
+        //         return sac.approve(args)
+        //     case SacCommands.Balance:
+        //         return sac.balance(args)
+        //     case SacCommands.Burn:
+        //         return sac.burn(args)
+        //     case SacCommands.BurnFrom:
+        //         return sac.burn_from(args)
+        //     case SacCommands.Clawback:
+        //         return sac.clawback(args)
+        //     case SacCommands.Decimals:
+        //         return sac.decimals(args)
+        //     case SacCommands.Mint:
+        //         return sac.mint(args)
+        //     case SacCommands.Name:
+        //         return sac.name(args)
+        //     case SacCommands.SetAdmin:
+        //         return sac.set_admin(args)
+        //     case SacCommands.Admin:
+        //         return sac.admin(args)
+        //     case SacCommands.SetAuthorized:
+        //         return sac.set_authorized(args)
+        //     case SacCommands.Symbol:
+        //         return sac.symbol(args)
+        //     case SacCommands.Transfer:
+        //         return sac.transfer(args)
+        //     case SacCommands.TransferFrom:
+        //         return sac.transfer_from(args)
+        //     default:
+        //         throw new Error('Invalid command')
+        // }
+
+        // const { SAC, from, to, amount, fee = 0 } = args
+        // const txn = new TransactionBuilder(mockSource, {
+        //     fee: fee.toString(),
+        //     networkPassphrase: import.meta.env.VITE_networkPassphrase
+        // })
+        //     .addOperation(Operation.invokeContractFunction({
+        //         contract: SAC,
+        //         function: 'transfer',
+        //         args: [
+        //             nativeToScVal(from, { type: 'address' }),
+        //             nativeToScVal(to, { type: 'address' }),
+        //             nativeToScVal(amount, { type: 'i128' })
+        //         ],
+        //     }))
+        //     .setTimeout(5 * 60)
+        //     .build()
+    
+        // const sim = await rpc.simulateTransaction(txn)
+    
+        // if (
+        //     SorobanRpc.Api.isSimulationError(sim)
+        //     || SorobanRpc.Api.isSimulationRestore(sim)
+        // ) throw sim
+    
+        // return {
+        //     txn,
+        //     sim,
+        //     built: SorobanRpc.assembleTransaction(txn, sim).build()
+        // }
+    }
+}

package/src/server.ts

@@ -0,0 +1,191 @@
+import { SorobanRpc, xdr } from "@stellar/stellar-sdk"
+import base64url from "base64url"
+import { PasskeyBase } from "./base"
+
+export class PasskeyServer extends PasskeyBase {
+    public launchtubeUrl: string | undefined
+    public launchtubeJwt: string | undefined
+    public mercuryUrl: string | undefined
+    public mercuryJwt: string | undefined
+    public mercuryEmail: string | undefined
+    public mercuryPassword: string | undefined
+
+    constructor(options: {
+        rpcUrl?: string,
+        launchtubeUrl?: string,
+        launchtubeJwt?: string,
+        mercuryUrl?: string,
+        mercuryJwt?: string,
+        mercuryEmail?: string,
+        mercuryPassword?: string
+    }) {
+        const {
+            rpcUrl,
+            launchtubeUrl,
+            launchtubeJwt,
+            mercuryUrl,
+            mercuryJwt,
+            mercuryEmail,
+            mercuryPassword
+        } = options
+
+        super(rpcUrl)
+
+        if (launchtubeUrl)
+            this.launchtubeUrl = launchtubeUrl
+
+        if (launchtubeJwt)
+            this.launchtubeJwt = launchtubeJwt
+
+        if (mercuryUrl)
+            this.mercuryUrl = mercuryUrl
+
+        if (mercuryJwt)
+            this.mercuryJwt = mercuryJwt
+
+        if (mercuryEmail)
+            this.mercuryEmail = mercuryEmail
+
+        if (mercuryPassword)
+            this.mercuryPassword = mercuryPassword
+    }
+
+    public async setMercuryJwt() {
+        if (!this.mercuryUrl || !this.mercuryEmail || !this.mercuryPassword)
+            throw new Error('Mercury service not configured')
+
+        const { data: { authenticate: { jwtToken } } } = await fetch(`${this.mercuryUrl}/graphql`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                query: `mutation {
+                    authenticate(input: {
+                        email: "${this.mercuryEmail}"
+                        password: "${this.mercuryPassword}"
+                    }) {
+                        jwtToken
+                    }
+                }`
+            })
+        })
+            .then(async (res) => {
+                if (res.ok)
+                    return res.json()
+
+                throw await res.json()
+            })
+
+        this.mercuryJwt = jwtToken
+        return jwtToken
+    }
+
+    public async getSigners(contractId: string) {
+        if (this.rpc && this.mercuryUrl && !this.mercuryJwt)
+            await this.setMercuryJwt()
+
+        if (!this.rpc || !this.mercuryUrl || !this.mercuryJwt)
+            throw new Error('Mercury service not configured')
+
+        const signers = await fetch(`${this.mercuryUrl}/zephyr/execute`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.mercuryJwt}`
+            },
+            body: JSON.stringify({
+                mode: {
+                    Function: {
+                        fname: "get_signers_by_address",
+                        arguments: JSON.stringify({
+                            address: contractId
+                        })
+                    }
+                }
+            })
+        })
+            .then(async (res) => {
+                if (res.ok)
+                    return res.json()
+
+                throw await res.json()
+            })
+
+        for (const signer of signers) {
+            if (!signer.admin) {
+                try {
+                    await this.rpc.getContractData(contractId, xdr.ScVal.scvBytes(signer.id), SorobanRpc.Durability.Temporary)
+                } catch {
+                    signer.expired = true
+                }
+            }
+
+            signer.id = base64url(signer.id)
+            signer.pk = base64url(signer.pk)
+        }
+
+        return signers as { id: string, pk: string, admin: boolean, expired?: boolean }[]
+    }
+
+    public async getContractId(keyId: string) {
+        if (this.mercuryUrl && !this.mercuryJwt)
+            await this.setMercuryJwt()
+
+        if (!this.mercuryUrl || !this.mercuryJwt)
+            return
+
+        const res = await fetch(`${this.mercuryUrl}/zephyr/execute`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.mercuryJwt}`
+            },
+            body: JSON.stringify({
+                mode: {
+                    Function: {
+                        fname: "get_address_by_signer",
+                        arguments: JSON.stringify({
+                            id: [...base64url.toBuffer(keyId)]
+                        })
+                    }
+                }
+            })
+        })
+            .then(async (res) => {
+                if (res.ok)
+                    return res.json()
+
+                throw await res.json()
+            })
+
+        return res[0]?.address as string | undefined
+    }
+
+    /* TODO 
+        - Add a method for getting a paginated or filtered list of all a wallet's events
+            @Later
+    */
+
+    public async send(xdr: string, fee: number = 10_000) {
+        if (!this.launchtubeUrl || !this.launchtubeJwt)
+            throw new Error('Launchtube service not configured')
+
+        const data = new FormData();
+
+        data.set('xdr', xdr);
+        data.set('fee', fee.toString());
+
+        return fetch(this.launchtubeUrl, {
+            method: 'POST',
+            headers: {
+                authorization: `Bearer ${this.launchtubeJwt}`,
+            },
+            body: data
+        }).then(async (res) => {
+            if (res.ok)
+                return res.json()
+            else throw await res.json()
+        })
+    }
+}

package/tsconfig.json

@@ -1,29 +1,32 @@
 {
   "compilerOptions": {
     "outDir": "./types",
-
     // Enable latest features
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",
-
     // Bundler mode
     "moduleResolution": "node",
     "allowImportingTsExtensions": true,
     "verbatimModuleSyntax": true,
     "declaration": true,
     "emitDeclarationOnly": true,
-
     // Best practices
     "strict": true,
     "skipLibCheck": true,
     "noFallthroughCasesInSwitch": true,
-
     // Some stricter flags (disabled by default)
     "noUnusedLocals": false,
     "noUnusedParameters": false,
     "noPropertyAccessFromIndexSignature": false,
     "strictNullChecks": true,
   },
-  "exclude": ["./demo", "./packages", "./types", "./contracts", "./zephyr", "./bun_tests"]
+  "exclude": [
+    "./bun_tests",
+    "./contracts", 
+    "./demo", 
+    "./packages",
+    "./types", 
+    "./zephyr", 
+  ]
 }

package/types/base.d.ts

@@ -1,29 +1,6 @@
 import { SorobanRpc } from "@stellar/stellar-sdk";
 export declare class PasskeyBase {
-    rpc: SorobanRpc.Server | undefined;
     rpcUrl: string | undefined;
-    launchtubeUrl: string | undefined;
-    launchtubeJwt: string | undefined;
-    mercuryUrl: string | undefined;
-    mercuryJwt: string | undefined;
-    mercuryEmail: string | undefined;
-    mercuryPassword: string | undefined;
-    constructor(options: {
-        rpcUrl?: string;
-        launchtubeUrl?: string;
-        launchtubeJwt?: string;
-        mercuryUrl?: string;
-        mercuryJwt?: string;
-        mercuryEmail?: string;
-        mercuryPassword?: string;
-    });
-    setMercuryJwt(): Promise<any>;
-    getSigners(contractId: string): Promise<{
-        id: string;
-        pk: string;
-        admin: boolean;
-        expired?: boolean;
-    }[]>;
-    getContractId(keyId: string): Promise<string | undefined>;
-    send(xdr: string, fee?: number): Promise<any>;
+    rpc: SorobanRpc.Server | undefined;
+    constructor(rpcUrl?: string);
 }

package/types/index.d.ts

@@ -1,3 +1,4 @@
-import { PasskeyBase } from "./base";
+import { PasskeyServer } from "./server";
 import { PasskeyKit } from "./kit";
-export { PasskeyBase, PasskeyKit };
+import { SACClient } from "./sac";
+export { PasskeyServer, PasskeyKit, SACClient };

package/types/kit.d.ts

@@ -1,9 +1,11 @@
 import { Client as PasskeyClient } from 'passkey-kit-sdk';
 import { Client as FactoryClient } from 'passkey-factory-sdk';
-import { xdr, Transaction } from '@stellar/stellar-sdk';
+import { xdr, Transaction, SorobanRpc } from '@stellar/stellar-sdk';
 import { Buffer } from 'buffer';
 import { PasskeyBase } from './base';
 export declare class PasskeyKit extends PasskeyBase {
+    rpc: SorobanRpc.Server;
+    rpcUrl: string;
     keyId: string | undefined;
     networkPassphrase: string;
     factory: FactoryClient;
@@ -12,12 +14,6 @@ export declare class PasskeyKit extends PasskeyBase {
         rpcUrl: string;
         networkPassphrase: string;
         factoryContractId: string;
-        launchtubeUrl?: string;
-        launchtubeJwt?: string;
-        mercuryUrl?: string;
-        mercuryJwt?: string;
-        mercuryEmail?: string;
-        mercuryPassword?: string;
     });
     createWallet(app: string, user: string): Promise<{
         keyId: Buffer;

package/types/sac.d.ts

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