@organigram/passkey-wallet 0.1.6

package/dist/eip1193.js

@@ -0,0 +1,103 @@
+import { createWalletClient, getAddress, hexToString, http, numberToHex } from 'viem';
+const normalizePersonalSignMessage = (message) => {
+    if (typeof message !== 'string') {
+        throw new Error('Passkey wallet expected a string message.');
+    }
+    if (message.startsWith('0x')) {
+        return hexToString(message);
+    }
+    return message;
+};
+export const createPasskeyWalletProvider = ({ wallet, chain, rpcUrl, switchChain, actions }) => {
+    const listeners = new Map();
+    let currentChain = chain;
+    const emit = (event, ...args) => {
+        listeners.get(event)?.forEach(listener => {
+            listener(...args);
+        });
+    };
+    const getWalletClient = () => createWalletClient({
+        account: wallet.account,
+        chain: currentChain,
+        transport: http(rpcUrl)
+    });
+    const request = (async ({ method, params }) => {
+        const requestParams = Array.isArray(params) ? params : [];
+        switch (method) {
+            case 'eth_requestAccounts':
+            case 'eth_accounts':
+                return [wallet.address];
+            case 'eth_chainId':
+                return numberToHex(currentChain.id);
+            case 'wallet_switchEthereumChain': {
+                const chainId = Number.parseInt(String(requestParams[0]?.chainId), 16);
+                currentChain = switchChain(chainId);
+                emit('chainChanged', numberToHex(currentChain.id));
+                return null;
+            }
+            case 'personal_sign':
+                return await wallet.account.signMessage({
+                    message: normalizePersonalSignMessage(requestParams[0])
+                });
+            case 'eth_sign':
+                return await wallet.account.signMessage({
+                    message: normalizePersonalSignMessage(requestParams[1])
+                });
+            case 'eth_signTypedData':
+            case 'eth_signTypedData_v3':
+            case 'eth_signTypedData_v4': {
+                const typedData = typeof requestParams[1] === 'string'
+                    ? JSON.parse(requestParams[1])
+                    : requestParams[1];
+                return await wallet.account.signTypedData(typedData);
+            }
+            case 'eth_sendTransaction':
+                return await getWalletClient().sendTransaction(requestParams[0]);
+            case 'organigram_addPasskey': {
+                return await actions.registerAdditionalPasskeyCredential({
+                    wallet,
+                    name: typeof requestParams[0] === 'object' &&
+                        requestParams[0] != null &&
+                        'name' in requestParams[0]
+                        ? String(requestParams[0].name ?? '')
+                        : undefined
+                });
+            }
+            case 'organigram_exportRecoveryPhrase':
+                return await actions.exportPasskeyWalletRecoveryPhrase({
+                    expectedAddress: wallet.address
+                });
+            default: {
+                const response = await fetch(rpcUrl, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    body: JSON.stringify({
+                        jsonrpc: '2.0',
+                        id: 1,
+                        method,
+                        params: requestParams
+                    })
+                });
+                const body = (await response.json());
+                if (body.error != null) {
+                    throw new Error(body.error.message ?? 'RPC request failed.');
+                }
+                return body.result;
+            }
+        }
+    });
+    return {
+        request,
+        on: (event, listener) => {
+            const eventListeners = listeners.get(event) ?? new Set();
+            eventListeners.add(listener);
+            listeners.set(event, eventListeners);
+        },
+        removeListener: (event, listener) => {
+            listeners.get(event)?.delete(listener);
+        }
+    };
+};
+export const normalizePasskeyWalletAddress = (address) => getAddress(address);

package/dist/errors.d.ts

@@ -0,0 +1,7 @@
+export declare const passkeyPrfUnavailableErrorMessage = "This password manager is not compatible with Organigram's passkey wallet. Please use a different password manager to unlock your wallet.";
+export declare class PasskeyPrfUnavailableError extends Error {
+    constructor(message?: string);
+}
+export declare class PasskeyVaultDecryptError extends Error {
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,13 @@
+export const passkeyPrfUnavailableErrorMessage = "This password manager is not compatible with Organigram's passkey wallet. Please use a different password manager to unlock your wallet.";
+export class PasskeyPrfUnavailableError extends Error {
+    constructor(message = passkeyPrfUnavailableErrorMessage) {
+        super(message);
+        this.name = 'PasskeyPrfUnavailableError';
+    }
+}
+export class PasskeyVaultDecryptError extends Error {
+    constructor(message = 'Unable to decrypt passkey wallet.') {
+        super(message);
+        this.name = 'PasskeyVaultDecryptError';
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './crypto';
+export * from './types';
+export * from './vault';
+export * from './wallet';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './crypto';
+export * from './types';
+export * from './vault';
+export * from './wallet';

package/dist/rainbowkit.d.ts

@@ -0,0 +1,14 @@
+import type { Wallet } from '@rainbow-me/rainbowkit';
+import { type OrganigramPasskeyProviderActions } from './eip1193';
+import { type OrganigramPasskeyCapabilities, type UnlockedPasskeyWallet } from './types';
+export { organigramPasskeyWalletIcon, organigramPasskeyWalletId } from './types';
+export declare const isOrganigramPasskeyConnector: ({ id }: {
+    id: string;
+}) => boolean;
+export type CreateOrganigramPasskeyWalletInput = OrganigramPasskeyProviderActions & {
+    unlockOrCreatePasskeyWallet: (input: {
+        capabilities: OrganigramPasskeyCapabilities;
+        targetChainId: number;
+    }) => Promise<UnlockedPasskeyWallet>;
+};
+export declare const createOrganigramPasskeyWallet: ({ unlockOrCreatePasskeyWallet, registerAdditionalPasskeyCredential, exportPasskeyWalletRecoveryPhrase }: CreateOrganigramPasskeyWalletInput) => Wallet;

package/dist/rainbowkit.js

@@ -0,0 +1,128 @@
+import { getAddress } from 'viem';
+import { createConnector } from 'wagmi';
+import { createPasskeyWalletProvider } from './eip1193';
+import { organigramPasskeyWalletIcon, organigramPasskeyWalletId } from './types';
+export { organigramPasskeyWalletIcon, organigramPasskeyWalletId } from './types';
+const walletName = 'Passkey Wallet';
+const passkeyConnectorIds = new Set([organigramPasskeyWalletId]);
+export const isOrganigramPasskeyConnector = ({ id }) => passkeyConnectorIds.has(id);
+export const createOrganigramPasskeyWallet = ({ unlockOrCreatePasskeyWallet, registerAdditionalPasskeyCredential, exportPasskeyWalletRecoveryPhrase }) => ({
+    id: organigramPasskeyWalletId,
+    name: walletName,
+    shortName: 'Passkey',
+    rdns: 'ai.organigram.passkey',
+    iconUrl: organigramPasskeyWalletIcon,
+    iconAccent: '#00C2A8',
+    iconBackground: '#18272B',
+    installed: true,
+    createConnector: (walletDetails) => createConnector(config => {
+        let provider = null;
+        let wallet = null;
+        let activeChain = config.chains[0];
+        const resolveChain = (chainId) => {
+            const chain = chainId == null
+                ? activeChain
+                : config.chains.find(candidate => candidate.id === chainId);
+            if (chain == null) {
+                throw new Error('Unsupported network for Passkey Wallet.');
+            }
+            return chain;
+        };
+        const getRpcUrl = (chain) => chain.rpcUrls.default.http[0] ?? chain.rpcUrls.public?.http[0] ?? '';
+        return {
+            ...walletDetails,
+            id: organigramPasskeyWalletId,
+            name: walletName,
+            type: 'passkey-wallet',
+            async connect(parameters) {
+                activeChain = resolveChain(parameters?.chainId);
+                const unlockedWallet = await unlockOrCreatePasskeyWallet({
+                    capabilities: parameters
+                        ?.capabilities ?? {},
+                    targetChainId: activeChain.id
+                });
+                wallet = {
+                    ...unlockedWallet,
+                    address: getAddress(unlockedWallet.address)
+                };
+                provider = createPasskeyWalletProvider({
+                    wallet,
+                    chain: activeChain,
+                    rpcUrl: getRpcUrl(activeChain),
+                    switchChain: chainId => {
+                        activeChain = resolveChain(chainId);
+                        config.emitter.emit('change', {
+                            chainId: activeChain.id
+                        });
+                        return activeChain;
+                    },
+                    actions: {
+                        registerAdditionalPasskeyCredential,
+                        exportPasskeyWalletRecoveryPhrase
+                    }
+                });
+                config.emitter.emit('connect', {
+                    accounts: [wallet.address],
+                    chainId: activeChain.id
+                });
+                if (parameters?.withCapabilities === true) {
+                    return {
+                        accounts: [
+                            {
+                                address: wallet.address,
+                                capabilities: {}
+                            }
+                        ],
+                        chainId: activeChain.id
+                    };
+                }
+                return {
+                    accounts: [wallet.address],
+                    chainId: activeChain.id
+                };
+            },
+            async disconnect() {
+                wallet = null;
+                provider = null;
+                config.emitter.emit('disconnect');
+            },
+            async getAccounts() {
+                return wallet == null ? [] : [wallet.address];
+            },
+            async getChainId() {
+                return activeChain.id;
+            },
+            async getProvider() {
+                if (provider == null) {
+                    throw new Error('Passkey Wallet is locked.');
+                }
+                return provider;
+            },
+            async isAuthorized() {
+                return wallet != null && wallet.expiresAt > Date.now();
+            },
+            async switchChain({ chainId }) {
+                activeChain = resolveChain(chainId);
+                config.emitter.emit('change', {
+                    chainId
+                });
+                return activeChain;
+            },
+            onAccountsChanged(accounts) {
+                config.emitter.emit('change', {
+                    accounts: accounts.map(account => getAddress(account))
+                });
+            },
+            onChainChanged(chainId) {
+                config.emitter.emit('change', {
+                    chainId: Number.parseInt(chainId, 16)
+                });
+            },
+            onDisconnect() {
+                wallet = null;
+                provider = null;
+                config.emitter.emit('disconnect');
+            }
+        };
+    })
+});

package/dist/types.d.ts

@@ -0,0 +1,45 @@
+import type { HDAccount } from 'viem/accounts';
+export declare const organigramPasskeyWalletId = "organigram-passkeys";
+export declare const organigramPasskeyWalletIcon = "/png/logo-gradient.png";
+export type OrganigramPasskeyCapabilities = {
+    method?: 'login' | 'register';
+    name?: string;
+    identity?: {
+        email: string;
+    };
+};
+export type PasskeyWalletLoginCapabilities = {
+    method: 'login';
+};
+export type PasskeyWalletRegistrationCapabilities = {
+    method: 'register';
+    name: string;
+    identity?: {
+        email: string;
+    };
+};
+export type PasskeyWalletCapabilities = PasskeyWalletLoginCapabilities | PasskeyWalletRegistrationCapabilities;
+export type IdentityPasskeyCapabilities = PasskeyWalletRegistrationCapabilities & {
+    identity: {
+        email: string;
+    };
+};
+export declare const buildIdentityPasskeyCapabilities: (email: string) => IdentityPasskeyCapabilities;
+export declare const buildPasskeyWalletCapabilities: () => PasskeyWalletCapabilities;
+export declare const buildEmailPasskeyCapabilities: (email: string) => IdentityPasskeyCapabilities;
+export type UnlockedPasskeyWallet = {
+    address: `0x${string}`;
+    account: HDAccount;
+    recoveryPhrase: string;
+    userEncryptionPrivateKey: JsonWebKey;
+    userEncryptionPublicKey: JsonWebKey;
+    userEncryptionKeyVersion: number;
+    credentialId: string;
+    expiresAt: number;
+};
+export type PasskeyRegistrationResult = {
+    address: `0x${string}`;
+    credentialId: string;
+};
+export type PasskeyProviderEvent = 'accountsChanged' | 'chainChanged' | 'disconnect';
+export type PasskeyProviderListener = (...args: unknown[]) => void;

package/dist/types.js

@@ -0,0 +1,17 @@
+export const organigramPasskeyWalletId = 'organigram-passkeys';
+export const organigramPasskeyWalletIcon = '/png/logo-gradient.png';
+const normalizePasskeyIdentityEmail = (email) => email.trim().toLowerCase();
+export const buildIdentityPasskeyCapabilities = (email) => {
+    const normalizedEmail = normalizePasskeyIdentityEmail(email);
+    return {
+        method: 'register',
+        name: normalizedEmail,
+        identity: {
+            email: normalizedEmail
+        }
+    };
+};
+export const buildPasskeyWalletCapabilities = () => ({
+    method: 'login'
+});
+export const buildEmailPasskeyCapabilities = buildIdentityPasskeyCapabilities;

package/dist/vault.d.ts

@@ -0,0 +1,10 @@
+export type PasskeyWalletVaultPayload = {
+    version: 1;
+    recoveryPhrase: string;
+    userEncryptionPrivateKey: JsonWebKey;
+    userEncryptionPublicKey: JsonWebKey;
+    userEncryptionKeyVersion: number;
+};
+export declare const serializePasskeyWalletVaultPayload: ({ recoveryPhrase, userEncryptionPrivateKey, userEncryptionPublicKey, userEncryptionKeyVersion }: Omit<PasskeyWalletVaultPayload, "version">) => string;
+export declare const parsePasskeyWalletVaultPayload: (plaintext: string) => PasskeyWalletVaultPayload;
+export declare const createPasskeyWalletVaultPayload: (recoveryPhrase: string) => Promise<PasskeyWalletVaultPayload>;

package/dist/vault.js

@@ -0,0 +1,41 @@
+import { createEncryptionKeyVersion, exportUserPrivateKey, exportUserPublicKey, generateUserEncryptionKeyPair } from '@organigram/js';
+export const serializePasskeyWalletVaultPayload = ({ recoveryPhrase, userEncryptionPrivateKey, userEncryptionPublicKey, userEncryptionKeyVersion }) => JSON.stringify({
+    version: 1,
+    recoveryPhrase,
+    userEncryptionPrivateKey,
+    userEncryptionPublicKey,
+    userEncryptionKeyVersion
+});
+export const parsePasskeyWalletVaultPayload = (plaintext) => {
+    const payload = JSON.parse(plaintext);
+    if (payload.version !== 1) {
+        throw new Error('Unsupported passkey wallet vault payload version.');
+    }
+    if (typeof payload.recoveryPhrase !== 'string' ||
+        payload.recoveryPhrase.trim() === '') {
+        throw new Error('Passkey wallet vault is missing its recovery phrase.');
+    }
+    if (payload.userEncryptionPrivateKey == null) {
+        throw new Error('Passkey wallet vault is missing its IPFS private key.');
+    }
+    if (payload.userEncryptionPublicKey == null) {
+        throw new Error('Passkey wallet vault is missing its IPFS public key.');
+    }
+    if (!Number.isInteger(payload.userEncryptionKeyVersion) ||
+        payload.userEncryptionKeyVersion == null) {
+        throw new Error('Passkey wallet vault has an invalid IPFS key version.');
+    }
+    return payload;
+};
+export const createPasskeyWalletVaultPayload = async (recoveryPhrase) => {
+    const userEncryptionKeyPair = await generateUserEncryptionKeyPair();
+    const userEncryptionPrivateKey = await exportUserPrivateKey(userEncryptionKeyPair);
+    const userEncryptionPublicKey = await exportUserPublicKey(userEncryptionKeyPair);
+    return {
+        version: 1,
+        recoveryPhrase,
+        userEncryptionPrivateKey,
+        userEncryptionPublicKey,
+        userEncryptionKeyVersion: createEncryptionKeyVersion()
+    };
+};

package/dist/wallet.d.ts

@@ -0,0 +1,15 @@
+import type { OrganigramPasskeyCapabilities, UnlockedPasskeyWallet } from './types';
+import { type PasskeyWalletVaultPayload } from './vault';
+export declare const unlockedPasskeyWalletTtlMs: number;
+export declare const createUnlockedPasskeyWallet: ({ address, credentialId, vaultPayload, now }: {
+    address: `0x${string}`;
+    credentialId: string;
+    vaultPayload: PasskeyWalletVaultPayload;
+    now?: number;
+}) => UnlockedPasskeyWallet;
+export declare const createNewPasskeyWalletVault: ({ capabilities }: {
+    capabilities: OrganigramPasskeyCapabilities;
+}) => Promise<{
+    address: `0x${string}`;
+    vaultPayload: PasskeyWalletVaultPayload;
+}>;

package/dist/wallet.js

@@ -0,0 +1,30 @@
+import { english, generateMnemonic, mnemonicToAccount } from 'viem/accounts';
+import { createPasskeyWalletVaultPayload } from './vault';
+export const unlockedPasskeyWalletTtlMs = 15 * 60 * 1000;
+export const createUnlockedPasskeyWallet = ({ address, credentialId, vaultPayload, now = Date.now() }) => {
+    const account = mnemonicToAccount(vaultPayload.recoveryPhrase);
+    return {
+        address,
+        account,
+        recoveryPhrase: vaultPayload.recoveryPhrase,
+        userEncryptionPrivateKey: vaultPayload.userEncryptionPrivateKey,
+        userEncryptionPublicKey: vaultPayload.userEncryptionPublicKey,
+        userEncryptionKeyVersion: vaultPayload.userEncryptionKeyVersion,
+        credentialId,
+        expiresAt: now + unlockedPasskeyWalletTtlMs
+    };
+};
+export const createNewPasskeyWalletVault = async ({ capabilities }) => {
+    const recoveryPhrase = generateMnemonic(english, 128);
+    const vaultPayload = await createPasskeyWalletVaultPayload(recoveryPhrase);
+    const account = mnemonicToAccount(recoveryPhrase);
+    return {
+        address: account.address,
+        vaultPayload: {
+            ...vaultPayload,
+            recoveryPhrase: capabilities.method === 'register'
+                ? vaultPayload.recoveryPhrase
+                : vaultPayload.recoveryPhrase
+        }
+    };
+};

package/dist/webauthn-client.d.ts

@@ -0,0 +1,73 @@
+import { startAuthentication, startRegistration } from '@simplewebauthn/browser';
+import { type PasskeyVaultEnvelopeData } from './crypto';
+import type { OrganigramPasskeyCapabilities, PasskeyRegistrationResult, UnlockedPasskeyWallet } from './types';
+import { parsePasskeyWalletVaultPayload, serializePasskeyWalletVaultPayload, type PasskeyWalletVaultPayload } from './vault';
+export { parsePasskeyWalletVaultPayload, serializePasskeyWalletVaultPayload };
+export type { OrganigramPasskeyCapabilities, UnlockedPasskeyWallet } from './types';
+type PasskeyRegisterOptionsResponse = {
+    options: Parameters<typeof startRegistration>[0]['optionsJSON'];
+};
+type PasskeyUnlockOptionsResponse = {
+    options: Parameters<typeof startAuthentication>[0]['optionsJSON'];
+    hasCredentials: boolean;
+};
+type PasskeyUnlockVerifyResponse = {
+    address: `0x${string}`;
+    credentialId: string;
+    envelope: PasskeyVaultEnvelopeData;
+};
+export type PasskeyWalletApiClient = {
+    registerOptions: (input: {
+        address: `0x${string}`;
+        email?: string | null;
+        name?: string | null;
+    }) => Promise<PasskeyRegisterOptionsResponse>;
+    registerVerify: (input: {
+        response: unknown;
+        envelope: {
+            address: `0x${string}`;
+            encryptedMnemonic: string;
+            salt: string;
+            nonce: string;
+            algorithm: string;
+            keyVersion: number;
+        };
+    }) => Promise<PasskeyRegistrationResult>;
+    unlockOptions: () => Promise<PasskeyUnlockOptionsResponse>;
+    unlockVerify: (input: {
+        response: unknown;
+    }) => Promise<PasskeyUnlockVerifyResponse>;
+};
+export declare const createFetchPasskeyWalletApiClient: (basePath?: string) => PasskeyWalletApiClient;
+export declare const hydratePasskeyPrfOptions: <T extends {
+    extensions?: unknown;
+}>(options: T) => T;
+export declare function registerPasskeyCredentialEnvelope({ api, address, vaultPayload, email, name }: {
+    api: PasskeyWalletApiClient;
+    address: `0x${string}`;
+    vaultPayload: PasskeyWalletVaultPayload;
+    email?: string | null;
+    name?: string | null;
+}): Promise<PasskeyRegistrationResult>;
+export declare const registerPasskeyWallet: ({ api, capabilities }: {
+    api: PasskeyWalletApiClient;
+    capabilities: OrganigramPasskeyCapabilities;
+}) => Promise<UnlockedPasskeyWallet>;
+export declare const unlockPasskeyWallet: ({ api }: {
+    api: PasskeyWalletApiClient;
+}) => Promise<UnlockedPasskeyWallet | null>;
+export declare const exportPasskeyWalletRecoveryPhrase: ({ api, expectedAddress }: {
+    api: PasskeyWalletApiClient;
+    expectedAddress: `0x${string}`;
+}) => Promise<string>;
+export declare const registerAdditionalPasskeyCredential: ({ api, wallet, name }: {
+    api: PasskeyWalletApiClient;
+    wallet: UnlockedPasskeyWallet;
+    name?: string;
+}) => Promise<PasskeyRegistrationResult>;
+export declare const isPasskeyCredentialUnavailableError: (error: unknown) => boolean;
+export declare const unlockOrCreatePasskeyWallet: ({ api, capabilities }: {
+    api: PasskeyWalletApiClient;
+    capabilities: OrganigramPasskeyCapabilities;
+    targetChainId: number;
+}) => Promise<UnlockedPasskeyWallet>;