@injectivelabs/wallet-turnkey 1.16.38-alpha.7 → 1.16.38

package/dist/esm/strategy/turnkey/turnkey.js

@@ -0,0 +1,255 @@
+import { createAccount } from '@turnkey/viem';
+import { HttpRestClient } from '@injectivelabs/utils';
+import { getInjectiveAddress } from '@injectivelabs/sdk-ts';
+import { Turnkey, SessionType } from '@turnkey/sdk-browser';
+import { WalletAction, TurnkeyProvider } from '@injectivelabs/wallet-base';
+import { ErrorType, WalletException, GeneralException, UnspecifiedErrorCode, TurnkeyWalletSessionException, } from '@injectivelabs/exceptions';
+import { TurnkeyOtpWallet } from './otp.js';
+import { TurnkeyErrorCodes } from '../types.js';
+import { TurnkeyOauthWallet } from './oauth.js';
+import { generateGoogleUrl } from '../../utils.js';
+import { TURNKEY_OAUTH_PATH, TURNKEY_OTP_INIT_PATH, TURNKEY_OTP_VERIFY_PATH, } from '../consts.js';
+export class TurnkeyWallet {
+    otpId;
+    turnkey;
+    userOrganizationId;
+    client;
+    metadata;
+    indexedDbClient;
+    accountMap = {};
+    setMetadata(metadata) {
+        this.metadata = { ...this.metadata, ...metadata };
+    }
+    constructor(metadata) {
+        this.metadata = metadata;
+        this.client = new HttpRestClient(metadata.apiServerEndpoint);
+    }
+    static async getTurnkeyInstance(metadata) {
+        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        return {
+            turnkey,
+            indexedDbClient,
+        };
+    }
+    async getTurnkey() {
+        if (!this.indexedDbClient) {
+            await this.initClient();
+        }
+        if (!this.turnkey) {
+            this.turnkey = new Turnkey(this.metadata);
+        }
+        return this.turnkey;
+    }
+    async getIndexedDbClient() {
+        if (!this.indexedDbClient) {
+            await this.initClient();
+        }
+        if (!this.indexedDbClient) {
+            throw new WalletException(new Error('Indexed DB client not initialized'));
+        }
+        return this.indexedDbClient;
+    }
+    async getSession(existingCredentialBundle) {
+        try {
+            const { metadata } = this;
+            const indexedDbClient = await this.getIndexedDbClient();
+            const turnkey = await this.getTurnkey();
+            const session = await turnkey.getSession();
+            const organizationId = session?.organizationId || metadata.defaultOrganizationId;
+            const credentialBundle = existingCredentialBundle || session?.token;
+            if (!credentialBundle) {
+                return {
+                    session: undefined,
+                    organizationId,
+                };
+            }
+            const user = await indexedDbClient.getWhoami();
+            const actualOrganizationId = user?.organizationId || session?.organizationId || organizationId;
+            if (!user) {
+                return {
+                    session: undefined,
+                    organizationId: actualOrganizationId,
+                };
+            }
+            this.userOrganizationId = actualOrganizationId;
+            return {
+                session,
+                organizationId: actualOrganizationId,
+            };
+        }
+        catch {
+            throw new TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
+        }
+    }
+    async getAccounts() {
+        const indexedDbClient = await this.getIndexedDbClient();
+        if (!this.userOrganizationId) {
+            return [];
+        }
+        try {
+            const response = await indexedDbClient.getWallets({
+                organizationId: this.userOrganizationId,
+            });
+            const accounts = await Promise.allSettled(response.wallets.map((wallet) => indexedDbClient.getWalletAccounts({
+                walletId: wallet.walletId,
+                organizationId: this.userOrganizationId,
+            })));
+            const filteredAccounts = accounts
+                .filter((account) => account.status === 'fulfilled')
+                .flatMap((result) => result.value?.accounts)
+                .filter((wa) => !!wa &&
+                wa.addressFormat === 'ADDRESS_FORMAT_ETHEREUM' &&
+                !!wa.address);
+            return filteredAccounts.map((account) => getInjectiveAddress(account.address));
+        }
+        catch (e) {
+            if (e.code === TurnkeyErrorCodes.UserLoggedOut) {
+                throw new WalletException(new Error('User is not logged in'), {
+                    code: UnspecifiedErrorCode,
+                    type: ErrorType.WalletError,
+                    contextModule: WalletAction.GetAccounts,
+                    contextCode: TurnkeyErrorCodes.UserLoggedOut,
+                });
+            }
+            throw new WalletException(new Error(e.message), {
+                code: UnspecifiedErrorCode,
+                type: ErrorType.WalletError,
+                contextModule: 'turnkey-wallet-get-accounts',
+            });
+        }
+    }
+    async getOrCreateAndGetAccount(address) {
+        const { accountMap } = this;
+        const indexedDbClient = await this.getIndexedDbClient();
+        const organizationId = this.userOrganizationId;
+        if (accountMap[address] || accountMap[address.toLowerCase()]) {
+            return accountMap[address] || accountMap[address.toLowerCase()];
+        }
+        if (!organizationId) {
+            throw new WalletException(new Error('Organization ID is required'));
+        }
+        indexedDbClient.config.organizationId = organizationId;
+        if (!address) {
+            throw new WalletException(new Error('Account address not found'));
+        }
+        const turnkeyAccount = await createAccount({
+            organizationId,
+            signWith: address,
+            client: indexedDbClient,
+        });
+        this.accountMap[address] = turnkeyAccount;
+        return turnkeyAccount;
+    }
+    async initOTP(email) {
+        const indexedDbClient = await this.getIndexedDbClient();
+        const result = await TurnkeyOtpWallet.initEmailOTP({
+            client: this.client,
+            indexedDbClient,
+            email,
+            otpInitPath: this.metadata.otpInitPath || TURNKEY_OTP_INIT_PATH,
+        });
+        if (!result || !result.otpId) {
+            throw new WalletException(new Error('Failed to initialize OTP'));
+        }
+        if (result?.organizationId) {
+            this.userOrganizationId = result.organizationId;
+        }
+        if (result?.otpId) {
+            this.otpId = result.otpId;
+        }
+        return result;
+    }
+    async confirmOTP(otpCode) {
+        const indexedDbClient = await this.getIndexedDbClient();
+        const targetPublicKey = await indexedDbClient.getPublicKey();
+        if (!this.otpId) {
+            throw new WalletException(new Error('OTP ID is required'));
+        }
+        if (!targetPublicKey) {
+            throw new WalletException(new Error('Target public key not found'));
+        }
+        if (!this.userOrganizationId) {
+            throw new WalletException(new Error('Organization ID is required'));
+        }
+        const result = await TurnkeyOtpWallet.confirmEmailOTP({
+            otpCode,
+            client: this.client,
+            emailOTPId: this.otpId,
+            organizationId: this.userOrganizationId,
+            targetPublicKey,
+            otpVerifyPath: this.metadata.otpVerifyPath || TURNKEY_OTP_VERIFY_PATH,
+        });
+        if (!result || !result.session) {
+            throw new WalletException(new Error('Failed to confirm OTP'));
+        }
+        await indexedDbClient.loginWithSession(result.session);
+        this.userOrganizationId = result.organizationId;
+        return result;
+    }
+    async initOAuth(provider) {
+        if (provider === TurnkeyProvider.Apple) {
+            throw new WalletException(new Error('Apple sign in option is currently not supported'));
+        }
+        const indexedDbClient = await this.getIndexedDbClient();
+        const nonce = await TurnkeyOauthWallet.generateOAuthNonce(indexedDbClient);
+        if (!this.metadata?.googleClientId || !this.metadata?.googleRedirectUri) {
+            throw new WalletException(new Error('googleClientId and googleRedirectUri are required'));
+        }
+        return generateGoogleUrl({
+            nonce,
+            clientId: this.metadata.googleClientId,
+            redirectUri: this.metadata.googleRedirectUri,
+        });
+    }
+    async confirmOAuth(provider, oidcToken) {
+        if (provider === TurnkeyProvider.Apple) {
+            throw new WalletException(new Error('Apple sign in option is currently not supported'));
+        }
+        const indexedDbClient = await this.getIndexedDbClient();
+        const oauthResult = await TurnkeyOauthWallet.oauthLogin({
+            oidcToken,
+            indexedDbClient,
+            client: this.client,
+            providerName: provider.toString(),
+            oauthLoginPath: this.metadata.oauthLoginPath || TURNKEY_OAUTH_PATH,
+        });
+        if (!oauthResult || !oauthResult.credentialBundle) {
+            throw new WalletException(new Error('Unexpected OAuth result'));
+        }
+        await indexedDbClient.loginWithSession(oauthResult.credentialBundle);
+        this.userOrganizationId = oauthResult.organizationId;
+        return oauthResult.credentialBundle;
+    }
+    async refreshSession() {
+        const session = await this.getSession();
+        const indexedDbClient = await this.getIndexedDbClient();
+        if (session.session?.token) {
+            await indexedDbClient.refreshSession({
+                sessionType: SessionType.READ_WRITE,
+                expirationSeconds: this.metadata.expirationSeconds,
+            });
+            this.userOrganizationId = session.organizationId;
+            return session.session.token;
+        }
+        throw new TurnkeyWalletSessionException(new Error('Session expired. Please login again.'));
+    }
+    async initClient() {
+        const { metadata } = this;
+        const { turnkey, indexedDbClient } = await createTurnkeyClient(metadata);
+        this.turnkey = turnkey;
+        this.indexedDbClient = indexedDbClient;
+        return { turnkey, indexedDbClient };
+    }
+}
+async function createTurnkeyClient(metadata) {
+    const turnkey = new Turnkey(metadata);
+    const indexedDbClient = await turnkey.indexedDbClient();
+    await indexedDbClient.init();
+    if (!turnkey) {
+        throw new GeneralException(new Error('Turnkey is not initialized'));
+    }
+    return {
+        turnkey,
+        indexedDbClient,
+    };
+}

package/dist/esm/strategy/types.d.ts

@@ -0,0 +1,28 @@
+export declare const TurnkeyErrorCodes: {
+    readonly UserLoggedOut: 7;
+};
+export type TurnkeyErrorCodes = (typeof TurnkeyErrorCodes)[keyof typeof TurnkeyErrorCodes];
+export type TurnkeyOAuthArgs = {
+    provider: 'google';
+    oidcToken: string;
+    oauthLoginEndpoint: string;
+};
+export type TurnkeyEmailArgs = {
+    provider: 'email';
+    email: string;
+    initEmailOTPEndpoint: string;
+};
+export type TurnkeyEnableArgs = TurnkeyOAuthArgs | TurnkeyEmailArgs;
+export type TurnkeyOTPCredentialsResponse = {
+    otpId: string;
+    organizationId: string;
+};
+export type TurnkeyConfirmEmailOTPResponse = {
+    session: string;
+    organizationId: string;
+};
+export type TurnkeyOauthLoginResponse = {
+    organizationId: string;
+    credentialBundle: string;
+    message: string;
+};

package/dist/esm/strategy/types.js

@@ -0,0 +1,3 @@
+export const TurnkeyErrorCodes = {
+    UserLoggedOut: 7,
+};

package/dist/esm/utils.d.ts

@@ -0,0 +1,7 @@
+export declare function generateGoogleUrl({ nonce, clientId, redirectUri, scope, prompt, }: {
+    nonce: string;
+    clientId: string;
+    redirectUri: string;
+    scope?: string;
+    prompt?: string;
+}): string;

package/dist/esm/utils.js

@@ -0,0 +1,7 @@
+export function generateGoogleUrl({ nonce, clientId, redirectUri, scope = 'openid profile email', prompt = 'consent', }) {
+    if (!clientId) {
+        throw new Error('Google client ID not found');
+    }
+    const responseType = 'id_token';
+    return `https://accounts.google.com/o/oauth2/v2/auth?prompt=${prompt}&client_id=${clientId}&redirect_uri=${redirectUri}&response_type=${responseType}&scope=${scope}&nonce=${nonce}`;
+}

package/package.json

@@ -1,71 +1,81 @@
 {
   "name": "@injectivelabs/wallet-turnkey",
-  "version": "1.16.38-alpha.7",
   "description": "Turnkey wallet strategy for use with @injectivelabs/wallet-core.",
-  "license": "Apache-2.0",
+  "version": "1.16.38",
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
   "author": {
     "name": "InjectiveLabs",
     "email": "admin@injectivelabs.org"
   },
-  "type": "module",
-  "sideEffects": false,
+  "license": "Apache-2.0",
+  "types": "dist/cjs/index.d.ts",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "files": [
+    "dist"
+  ],
+  "_moduleAliases": {
+    "~wallet-turnkey": "dist"
+  },
   "exports": {
     ".": {
       "react-native": {
         "import": "./dist/esm/index.js",
-        "require": "./dist/cjs/index.cjs",
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
+        "require": "./dist/cjs/index.js",
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
       },
       "require": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
       },
       "import": {
         "types": "./dist/esm/index.d.ts",
         "default": "./dist/esm/index.js"
       },
       "default": {
-        "types": "./dist/cjs/index.d.cts",
-        "default": "./dist/cjs/index.cjs"
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
       }
     }
   },
-  "main": "dist/cjs/index.cjs",
-  "module": "dist/esm/index.js",
-  "types": "dist/cjs/index.d.cts",
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "@turnkey/sdk-browser": "^5.13.4",
-    "@turnkey/viem": "^0.14.16",
-    "viem": "^2.41.2",
-    "@injectivelabs/exceptions": "1.16.38-alpha.4",
-    "@injectivelabs/sdk-ts": "1.16.38-alpha.7",
-    "@injectivelabs/ts-types": "1.16.38-alpha.3",
-    "@injectivelabs/utils": "1.16.38-alpha.5",
-    "@injectivelabs/wallet-base": "1.16.38-alpha.7"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "_moduleAliases": {
-    "~wallet-turnkey": "dist"
-  },
   "scripts": {
-    "build": "pnpm type-check && tsdown",
-    "build:fast": "tsdown",
-    "build:watch": "tsdown --watch",
-    "clean": "shx rm -rf dist coverage *.log junit.xml && shx mkdir -p dist",
-    "type-check": "tsc --noEmit",
-    "test": "vitest",
-    "test:watch": "vitest --watch",
-    "test:ci": "vitest run --coverage --reporter=verbose",
-    "coverage": "vitest run --coverage",
+    "build": "pnpm build:esm && pnpm build:cjs && pnpm build:post",
+    "build:cjs": "tsc --build --force tsconfig.build.json",
+    "build:esm": "tsc --build --force tsconfig.build.esm.json",
+    "build:watch": "tsc --build -w tsconfig.build.json && tsc -w --build tsconfig.build.esm.json && pnpm build:post",
+    "build:post": "shx cp ../../../etc/stub/package.json.stub dist/cjs/package.json && shx cp ../../../etc/stub/package.esm.json.stub dist/esm/package.json",
+    "clean": "tsc --build tsconfig.build.json --clean && tsc --build tsconfig.build.esm.json --clean && shx rm -rf coverage *.log junit.xml dist && jest --clearCache && shx mkdir -p dist",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:ci": "jest --coverage --ci --reporters='jest-junit'",
+    "coverage": "jest --coverage",
     "coverage:show": "live-server coverage",
     "dev": "ts-node -r tsconfig-paths/register src/index.ts",
-    "start": "node dist/index.js",
-    "lint": "eslint . --ext .ts,.js"
-  }
-}
+    "start": "node dist/index.js"
+  },
+  "dependencies": {
+    "@injectivelabs/exceptions": "1.16.38",
+    "@injectivelabs/sdk-ts": "1.16.38",
+    "@injectivelabs/ts-types": "1.16.38",
+    "@injectivelabs/utils": "1.16.38",
+    "@injectivelabs/wallet-base": "1.16.38",
+    "@turnkey/sdk-browser": "5.2.3",
+    "@turnkey/viem": "^0.9.10",
+    "viem": "^2.40.3"
+  },
+  "devDependencies": {
+    "jest": "^29.0.0",
+    "live-server": "^1.2.1",
+    "shx": "^0.3.4",
+    "ts-jest": "^29.0.0",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.0.0"
+  },
+  "gitHead": "c67633f9ba4c5efb2c969c3df815d54995459966"
+}