@dynamic-labs/embedded-wallet-solana 3.0.0-alpha.8 → 3.0.0

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.js

@@ -5,13 +5,13 @@ import { WebauthnStamper } from '@turnkey/webauthn-stamper';
 import { TurnkeyClient } from '@turnkey/http';
 import { TurnkeySigner } from '@turnkey/solana';
 import { IframeStamper } from '@turnkey/iframe-stamper';
-import { ProviderChain } from '@dynamic-labs/rpc-provider-solana';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
 import { DynamicError, getTLD, PlatformService, bufferToBase64 } from '@dynamic-labs/utils';
-import { SolanaUiTransaction } from '@dynamic-labs/solana-utils';
-import { TurnkeyWalletConnectorBase, findTurnkeyVerifiedCredential, PasskeyService, TURNKEY_API_BASE_URL } from '@dynamic-labs/embedded-wallet';
+import { SolanaWallet, ProviderChain, getGenesisHashLSKey, SolanaUiTransaction } from '@dynamic-labs/solana-core';
+import { TurnkeyWalletConnectorBase, findTurnkeyVerifiedCredentials, PasskeyService, TURNKEY_API_BASE_URL, TURNKEY_SDK_SESSION_KEY_RETRYABLE_ERRORS, logger } from '@dynamic-labs/embedded-wallet';
 import { createSolanaConnection } from '../utils/createSolanaConnection/createSolanaConnection.js';
-import { getGenesisHashLSKey } from '../utils/getGenesisHashLSKey/getGenesisHashLSKey.js';
-import { decodeTransaction, summarizeTransactionDecodedData } from '../utils/transactionDecoder/transactionDecoder.js';
+import { decodeTransaction, getTotalSolanaSpend, summarizeTransactionDecodedData } from '../utils/transactionDecoder/transactionDecoder.js';
+import { optimizeSolanaTransaction } from '../utils/api/api.js';
 import { TurnkeySolanaSigner } from './TurnkeySolanaSigner.js';
 
 class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
@@ -19,9 +19,32 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
         var _a;
         super(nameAndKey, props);
         // Public fields
+        this.ChainWallet = SolanaWallet;
         this.connectedChain = 'SOL';
         this.supportedChains = ['SOL'];
         this.verifiedCredentialChain = 'solana';
+        this.getEnvId = () => {
+            const dynamicNonce = localStorage.getItem('dynamic_nonce');
+            if (dynamicNonce) {
+                const parsed = JSON.parse(dynamicNonce);
+                if (parsed && parsed.environmentId) {
+                    return parsed.environmentId;
+                }
+            }
+            const dynamicNonceDemo = localStorage.getItem('dynamic_nonce_demo');
+            if (dynamicNonceDemo) {
+                const parsed = JSON.parse(dynamicNonceDemo);
+                if (parsed && parsed.environmentId) {
+                    return parsed.environmentId;
+                }
+            }
+            throw new Error('Failed to get environment id');
+        };
+        this.stampCreateWalletAccountRequest = (_b) => __awaiter(this, [_b], void 0, function* ({ request, }) {
+            yield this.createOrRestoreSession();
+            const turnkeyClient = this.getTurnkeyClient();
+            return turnkeyClient.stampCreateWalletAccounts(request);
+        });
         this.solNetworks = props.solNetworks;
         this.walletUiUtils = props.walletUiUtils;
         this._turnkeyAccount = undefined;
@@ -92,15 +115,32 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
         return false;
     }
     setVerifiedCredentials(verifiedCredentials) {
-        const turnkeyVerifiedCredential = findTurnkeyVerifiedCredential(verifiedCredentials, ProviderChain.SOLANA);
-        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredential) !==
-            JSON.stringify(turnkeyVerifiedCredential);
+        const turnkeyVerifiedCredentials = findTurnkeyVerifiedCredentials(verifiedCredentials, ProviderChain.SOLANA);
+        const [turnkeyVerifiedCredential] = turnkeyVerifiedCredentials;
+        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredentials) !==
+            JSON.stringify(turnkeyVerifiedCredentials);
         if (!didTurnkeyVerifiedCredentialsChanged) {
             return;
         }
         this.verifiedCredential = turnkeyVerifiedCredential;
+        this.verifiedCredentials = turnkeyVerifiedCredentials;
         this.refreshTurnkeyAccount();
     }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const activeAddress = ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address) || '';
+            const isWalletActive = isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (!isWalletActive) {
+                const targetActiveAccount = (_b = this.verifiedCredentials) === null || _b === void 0 ? void 0 : _b.find((vc) => (vc === null || vc === void 0 ? void 0 : vc.address) === expectedAddress);
+                if (!targetActiveAccount) {
+                    throw new DynamicError('Account not found');
+                }
+                this.verifiedCredential = targetActiveAccount;
+                this.refreshTurnkeyAccount();
+            }
+        });
+    }
     getAccount() {
         return this.turnkeyAddress;
     }
@@ -158,23 +198,17 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
             this._turnkeyAccount = yield this.createTurnkeyAccount({
                 organizationId: turnkeySubOrganizationId,
             });
+            this.setLoggerMetadata();
             return this._turnkeyAccount;
         });
     }
     getSigner() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.isSessionKeyCompatible()) {
-                yield this.createOrRestoreSession();
-            }
             return new TurnkeySolanaSigner({ walletConnector: this });
         });
     }
-    getBalance() {
+    getBalance(address) {
         return __awaiter(this, void 0, void 0, function* () {
-            const address = this.getAccount();
-            if (!address) {
-                return undefined;
-            }
             const connectionClient = this.getConnection();
             const publicKey = new PublicKey(address);
             const balance = yield connectionClient.getBalance(publicKey);
@@ -182,34 +216,72 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
             return solBalance.toString();
         });
     }
-    signMessage(messageToSign) {
+    signUint8ArrayMessage(encodedMessage) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.turnkeyAddress) {
                 throw new DynamicError('No turnkey account');
             }
             const address = this.turnkeyAddress;
-            const signedMessage = yield this.walletUiUtils.signMessage({
+            let signedMessageRaw;
+            yield this.createOrRestoreSession();
+            yield this.walletUiUtils.signMessage({
                 handler: () => __awaiter(this, void 0, void 0, function* () {
-                    var _a;
-                    const enc = new TextEncoder();
-                    const encodedMessage = enc.encode(messageToSign);
-                    const signedMessageRaw = yield ((_a = (yield this.getTurnkeyAccount())) === null || _a === void 0 ? void 0 : _a.signMessage(encodedMessage, address));
+                    let account = yield this.getTurnkeyAccount();
+                    try {
+                        signedMessageRaw = yield (account === null || account === void 0 ? void 0 : account.signMessage(encodedMessage, address));
+                    }
+                    catch (_a) {
+                        yield this.removeSessionKeys();
+                        yield this.createOrRestoreSession({
+                            ignoreRestore: true,
+                        });
+                        account = yield this.getTurnkeyAccount();
+                        signedMessageRaw = yield (account === null || account === void 0 ? void 0 : account.signMessage(encodedMessage, address));
+                    }
                     return bufferToBase64(signedMessageRaw || Buffer.from([]));
                 }),
-                message: messageToSign,
+                message: new TextDecoder().decode(encodedMessage),
             });
-            return signedMessage;
+            if (!signedMessageRaw) {
+                throw new Error('Failed to sign message');
+            }
+            return signedMessageRaw;
         });
     }
-    signTransaction(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ transaction, }) {
-            const account = yield this.getTurnkeyAccount();
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enc = new TextEncoder();
+            const encodedMessage = enc.encode(messageToSign);
+            const signedRawMessage = yield this.signUint8ArrayMessage(encodedMessage);
+            return bufferToBase64(signedRawMessage);
+        });
+    }
+    signTransaction(transaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.createOrRestoreSession();
+            let account = yield this.getTurnkeyAccount();
             const address = this.turnkeyAddress;
             if (!account || !address) {
                 throw new Error('No turnkey account');
             }
-            yield account.addSignature(transaction, address);
-            return Buffer.from(transaction.serialize());
+            try {
+                yield account.addSignature(transaction, address);
+            }
+            catch (err) {
+                if (TURNKEY_SDK_SESSION_KEY_RETRYABLE_ERRORS.some((errorMsg) => err.message.includes(errorMsg))) {
+                    yield this.removeSessionKeys();
+                    yield this.createOrRestoreSession({
+                        ignoreRestore: true,
+                    });
+                    account = (yield this.getTurnkeyAccount());
+                    yield account.addSignature(transaction, address);
+                }
+                else {
+                    logger.error('[TK] failed to perform SignTransaction activity', err);
+                    throw err;
+                }
+            }
+            return transaction;
         });
     }
     internalSignAndSendTransaction(transaction, options) {
@@ -228,8 +300,8 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
                 transaction.feePayer =
                     (_a = transaction.feePayer) !== null && _a !== void 0 ? _a : new PublicKey(this.turnkeyAddress);
             }
-            const signedTransaction = yield this.signTransaction({ transaction });
-            const signature = yield currentConnection.sendRawTransaction(signedTransaction, options);
+            const signedTransaction = yield this.signTransaction(transaction);
+            const signature = yield currentConnection.sendRawTransaction(Buffer.from(signedTransaction.serialize()), options);
             // listen for tx confirmation until 60 seconds, which is ~150 blocks expiration
             return new Promise((resolve, reject) => {
                 const timeout = setTimeout(() => {
@@ -249,21 +321,45 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
     }
     signAndSendTransaction(transaction, options) {
         return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.turnkeyAddress)
                 throw new DynamicError('Solana wallet not found');
-            const transactionsData = yield decodeTransaction(transaction, this.getConnection(), this.turnkeyAddress);
+            let optimizedTransaction = transaction;
+            try {
+                if ((yield this.getNetwork()) === 'mainnet') {
+                    optimizedTransaction = (yield optimizeSolanaTransaction(this.getEnvId(), transaction, (_a = this.turnkeyAddress) !== null && _a !== void 0 ? _a : ''));
+                }
+            }
+            catch (e) {
+                logger.warn('Failed to optimize transaction', e);
+            }
+            const transactionsData = yield decodeTransaction(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
             if (!(transactionsData === null || transactionsData === void 0 ? void 0 : transactionsData.length)) {
                 throw new DynamicError('Incorrectly formatted transaction instructions');
             }
-            const { to, value } = summarizeTransactionDecodedData(transactionsData);
+            let spent;
+            let insufficientFunds = false;
+            try {
+                spent = yield getTotalSolanaSpend(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
+            }
+            catch (e) {
+                if (e.message === 'Insufficient funds') {
+                    insufficientFunds = true;
+                }
+            }
+            const to = summarizeTransactionDecodedData(transactionsData);
             const uiTransaction = new SolanaUiTransaction({
                 connection: this.getConnection(),
                 from: this.turnkeyAddress,
-                onSubmit: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction, options); }),
-                originalTransaction: transaction,
+                onSubmit: () => __awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(optimizedTransaction, options); }),
+                originalTransaction: optimizedTransaction,
             });
             uiTransaction.to = to;
-            uiTransaction.value = value;
+            uiTransaction.value = spent;
+            if (insufficientFunds) {
+                uiTransaction.notEnoughFundsError = true;
+            }
+            // TODO: remove this. We should not be passing references to wallet connectors
             return this.walletUiUtils.sendTransaction(this, uiTransaction);
         });
     }
@@ -307,11 +403,14 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
     }
     createUiTransaction(from) {
         return __awaiter(this, void 0, void 0, function* () {
-            return new SolanaUiTransaction({
+            yield this.validateActiveWallet(from);
+            const transaction = new SolanaUiTransaction({
                 connection: this.getConnection(),
                 from,
                 onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction); }),
             });
+            transaction.feeDeducted = true;
+            return transaction;
         });
     }
 }

package/src/lib/utils/api/api.cjs

@@ -0,0 +1,38 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var SdkApi = require('./utils/SdkApi.cjs');
+
+const serializeTransaction = (transaction) => {
+    if (transaction instanceof web3_js.VersionedTransaction) {
+        return Buffer.from(transaction.serialize()).toString('base64');
+    }
+    else {
+        return Buffer.from(transaction.serialize({ verifySignatures: false })).toString('base64');
+    }
+};
+const deserializeTransaction = (serializedTransaction) => {
+    const transactionBuffer = Buffer.from(serializedTransaction, 'base64');
+    return web3_js.VersionedTransaction.deserialize(transactionBuffer);
+};
+const optimizeSolanaTransaction = (environmentId, transaction, address) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const serializedTransaction = serializeTransaction(transaction);
+    const request = {
+        environmentId,
+        solanaTransactionOptimizationRequest: {
+            address,
+            transaction: serializedTransaction,
+        },
+    };
+    const response = yield SdkApi.sdkApi().optimizeTransaction(request);
+    const optimizedTransaction = deserializeTransaction(response.transaction);
+    return optimizedTransaction;
+});
+
+exports.deserializeTransaction = deserializeTransaction;
+exports.optimizeSolanaTransaction = optimizeSolanaTransaction;
+exports.serializeTransaction = serializeTransaction;

package/src/lib/utils/api/api.d.ts

@@ -0,0 +1,4 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export declare const serializeTransaction: (transaction: Transaction | VersionedTransaction) => string;
+export declare const deserializeTransaction: (serializedTransaction: string) => VersionedTransaction;
+export declare const optimizeSolanaTransaction: (environmentId: string, transaction: Transaction | VersionedTransaction, address: string) => Promise<VersionedTransaction>;

package/src/lib/utils/api/api.js

@@ -0,0 +1,32 @@
+'use client'
+import { __awaiter } from '../../../../_virtual/_tslib.js';
+import { VersionedTransaction } from '@solana/web3.js';
+import { sdkApi } from './utils/SdkApi.js';
+
+const serializeTransaction = (transaction) => {
+    if (transaction instanceof VersionedTransaction) {
+        return Buffer.from(transaction.serialize()).toString('base64');
+    }
+    else {
+        return Buffer.from(transaction.serialize({ verifySignatures: false })).toString('base64');
+    }
+};
+const deserializeTransaction = (serializedTransaction) => {
+    const transactionBuffer = Buffer.from(serializedTransaction, 'base64');
+    return VersionedTransaction.deserialize(transactionBuffer);
+};
+const optimizeSolanaTransaction = (environmentId, transaction, address) => __awaiter(void 0, void 0, void 0, function* () {
+    const serializedTransaction = serializeTransaction(transaction);
+    const request = {
+        environmentId,
+        solanaTransactionOptimizationRequest: {
+            address,
+            transaction: serializedTransaction,
+        },
+    };
+    const response = yield sdkApi().optimizeTransaction(request);
+    const optimizedTransaction = deserializeTransaction(response.transaction);
+    return optimizedTransaction;
+});
+
+export { deserializeTransaction, optimizeSolanaTransaction, serializeTransaction };

package/src/lib/utils/api/events/DynamicEvents.d.ts

@@ -0,0 +1,6 @@
+import EventEmitter from 'eventemitter3';
+import { AuthEvents } from './auth';
+/** Maps internal event names to their listeners */
+export type DynamicEvents = AuthEvents;
+export declare const dynamicEvents: EventEmitter<AuthEvents, any>;
+export type DynamicEventEmitter = typeof dynamicEvents;

package/src/lib/utils/api/events/auth.d.ts

@@ -0,0 +1,49 @@
+import { AuthMethod, AuthOptions } from '@dynamic-labs/types';
+/**
+ * Maps auth methods to what property will be displayed under the "option" property of the event.
+ *
+ * Users will be able to access this data through the AuthOptions[K] type injection as well,
+ * but with the "option" property they will also have a standard way to access the auth method target.
+ */
+type AuthEventPayloadOptionMap = {
+    wallet: AuthOptions['wallet']['connectorName'];
+    sms: AuthOptions['sms']['phone'];
+    email: AuthOptions['email']['email'];
+    social: AuthOptions['social']['provider'];
+    externalAuth: AuthOptions['externalAuth']['externalUserId'];
+};
+/** Payload of auth events that provide insight into which auth method was selected */
+export type AuthEventPayload = {
+    [K in AuthMethod]: {
+        type: K;
+        option: AuthEventPayloadOptionMap[K];
+    } & AuthOptions[K];
+}[AuthMethod];
+export type AuthEvents = {
+    /**
+     * Informs an auth attempt failed.
+     * In general triggered when an error occurs or when user cancels out.
+     * For email/sms, specifically happens when users cancels the OTP verification.
+     */
+    authFailure: (method: AuthEventPayload, 
+    /** Will be 'user-cancelled' when cancelled, or the error when there is an error */
+    reason: 'user-cancelled' | {
+        error: unknown;
+    }) => void;
+    /** Informs an auth attempt initialized, and provides insight into which auth option it is */
+    authInit: (method: AuthEventPayload) => void;
+    logout: () => void;
+    /**
+     * Emitted when the user succesfully completes an MFA challenge
+     */
+    mfaCompletionSuccess: (args: {
+        mfaToken?: string;
+    }) => void;
+    /**
+     * Emitted when there is an error verifiyng the MFA challenge
+     */
+    mfaCompletionFailure: (args: {
+        error: unknown;
+    }) => void;
+};
+export {};

package/src/lib/utils/api/utils/ApiEndpoint.cjs

@@ -0,0 +1,41 @@
+'use client'
+'use strict';
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+
+/* eslint-disable no-underscore-dangle */
+class ApiEndpoint {
+}
+ApiEndpoint.getBaseUrl = () => {
+    if (!ApiEndpoint.__defined__) {
+        throw new Error('ApiEndpoint Base URL has not been initialized');
+    }
+    return ApiEndpoint.__baseUrl__;
+};
+ApiEndpoint.setBaseUrl = (baseUrlInput) => {
+    if (!ApiEndpoint.__defined__) {
+        if (!baseUrlInput) {
+            /**
+             * If the baseUrl is not provided, use the default baseUrl from the sdk-api package
+             */
+            ApiEndpoint.__baseUrl__ = new sdkApiCore.Configuration().basePath;
+        }
+        else {
+            ApiEndpoint.__baseUrl__ = baseUrlInput;
+        }
+        ApiEndpoint.__defined__ = true;
+    }
+    else if (!baseUrlInput && ApiEndpoint.__defined__) {
+        /**
+         * If for some reason (usually in local development), the setBaseUrl is called multiple times with undefined
+         * And we already have it defined, let's just assume it's a no-op
+         */
+        return;
+    }
+    else if (ApiEndpoint.__baseUrl__ !== baseUrlInput) {
+        throw new Error(`ApiEndpoint baseUrl is already set to ${ApiEndpoint.__baseUrl__}, cannot change it to ${baseUrlInput}`);
+    }
+    Object.freeze(ApiEndpoint);
+};
+
+module.exports = ApiEndpoint;

package/src/lib/utils/api/utils/ApiEndpoint.d.ts

@@ -0,0 +1,7 @@
+declare class ApiEndpoint {
+    private static __baseUrl__;
+    private static __defined__;
+    static getBaseUrl: () => string | undefined;
+    static setBaseUrl: (baseUrlInput?: string) => void;
+}
+export default ApiEndpoint;

package/src/lib/utils/api/utils/ApiEndpoint.js

@@ -0,0 +1,39 @@
+'use client'
+import { Configuration } from '@dynamic-labs/sdk-api-core';
+
+/* eslint-disable no-underscore-dangle */
+class ApiEndpoint {
+}
+ApiEndpoint.getBaseUrl = () => {
+    if (!ApiEndpoint.__defined__) {
+        throw new Error('ApiEndpoint Base URL has not been initialized');
+    }
+    return ApiEndpoint.__baseUrl__;
+};
+ApiEndpoint.setBaseUrl = (baseUrlInput) => {
+    if (!ApiEndpoint.__defined__) {
+        if (!baseUrlInput) {
+            /**
+             * If the baseUrl is not provided, use the default baseUrl from the sdk-api package
+             */
+            ApiEndpoint.__baseUrl__ = new Configuration().basePath;
+        }
+        else {
+            ApiEndpoint.__baseUrl__ = baseUrlInput;
+        }
+        ApiEndpoint.__defined__ = true;
+    }
+    else if (!baseUrlInput && ApiEndpoint.__defined__) {
+        /**
+         * If for some reason (usually in local development), the setBaseUrl is called multiple times with undefined
+         * And we already have it defined, let's just assume it's a no-op
+         */
+        return;
+    }
+    else if (ApiEndpoint.__baseUrl__ !== baseUrlInput) {
+        throw new Error(`ApiEndpoint baseUrl is already set to ${ApiEndpoint.__baseUrl__}, cannot change it to ${baseUrlInput}`);
+    }
+    Object.freeze(ApiEndpoint);
+};
+
+export { ApiEndpoint as default };

package/src/lib/utils/api/utils/SdkApi.cjs

@@ -0,0 +1,35 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var utils = require('@dynamic-labs/utils');
+var helpers = require('./helpers.cjs');
+var ApiEndpoint = require('./ApiEndpoint.cjs');
+var version = require('./version.cjs');
+
+const sdkApi = () => {
+    const baseUrl = process.env.API_BASE_URL ||
+        process.env.NX_API_BASE_URL ||
+        'https://app.dynamic.xyz/api/v0';
+    ApiEndpoint.setBaseUrl(baseUrl);
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    const minJwt = helpers.getMinAuthToken();
+    if (minJwt) {
+        settings.headers.Authorization = `Bearer ${minJwt}`;
+    }
+    const credentials = helpers.isCookieEnabled()
+        ? 'include'
+        : undefined;
+    settings.headers['x-dyn-version'] = `WalletKit/${version.VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${version.API_VERSION}`;
+    return new sdkApiCore.SDKApi(new sdkApiCore.Configuration(Object.assign(Object.assign({}, settings), { credentials, fetchApi: utils.FetchService.fetch })));
+};
+
+exports.sdkApi = sdkApi;

package/src/lib/utils/api/utils/SdkApi.d.ts

@@ -0,0 +1,2 @@
+import { SDKApi } from '@dynamic-labs/sdk-api-core';
+export declare const sdkApi: () => SDKApi;

package/src/lib/utils/api/utils/SdkApi.js

@@ -0,0 +1,31 @@
+'use client'
+import { SDKApi, Configuration } from '@dynamic-labs/sdk-api-core';
+import { FetchService } from '@dynamic-labs/utils';
+import { getMinAuthToken, isCookieEnabled } from './helpers.js';
+import ApiEndpoint from './ApiEndpoint.js';
+import { VERSION, API_VERSION } from './version.js';
+
+const sdkApi = () => {
+    const baseUrl = process.env.API_BASE_URL ||
+        process.env.NX_API_BASE_URL ||
+        'https://app.dynamic.xyz/api/v0';
+    ApiEndpoint.setBaseUrl(baseUrl);
+    const settings = {
+        basePath: ApiEndpoint.getBaseUrl(),
+        headers: {
+            'Content-Type': 'application/json',
+        },
+    };
+    const minJwt = getMinAuthToken();
+    if (minJwt) {
+        settings.headers.Authorization = `Bearer ${minJwt}`;
+    }
+    const credentials = isCookieEnabled()
+        ? 'include'
+        : undefined;
+    settings.headers['x-dyn-version'] = `WalletKit/${VERSION}`;
+    settings.headers['x-dyn-api-version'] = `API/${API_VERSION}`;
+    return new SDKApi(new Configuration(Object.assign(Object.assign({}, settings), { credentials, fetchApi: FetchService.fetch })));
+};
+
+export { sdkApi };

package/src/lib/utils/api/utils/helpers.cjs

@@ -0,0 +1,92 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var sdkApiCore = require('@dynamic-labs/sdk-api-core');
+var logger$1 = require('@dynamic-labs/logger');
+var utils = require('@dynamic-labs/utils');
+
+const logger = new logger$1.Logger('DynamicSDK');
+const AUTH_MIN_TOKEN = 'dynamic_min_authentication_token';
+const AUTH_MIN_TOKEN_DEMO = 'dynamic_min_authentication_token_demo';
+const isCookieEnabled = () => {
+    var _a, _b, _c, _d;
+    let securitySettings = (_a = utils.StorageService.getItem('dynamic_store')) !== null && _a !== void 0 ? _a : utils.StorageService.getItem('dynamic_store_demo');
+    securitySettings = (_b = securitySettings === null || securitySettings === void 0 ? void 0 : securitySettings.settings) === null || _b === void 0 ? void 0 : _b.security;
+    if (!securitySettings)
+        return false;
+    // client uses Dynamic cookies
+    const dynamicCookiesEnabled = (((_c = securitySettings.auth) === null || _c === void 0 ? void 0 : _c.storage) || []).includes(sdkApiCore.AuthStorageEnum.Cookie);
+    // BYO JWT client puts their non-Dynamic JWT in a cookie
+    const byoJwtCookieEnabled = Boolean((_d = securitySettings.externalAuth) === null || _d === void 0 ? void 0 : _d.cookieName);
+    // should return true for both of these scenarios
+    // because we also need to do `credentials: true` in api.ts when
+    // a byo jwt client sets their named cookie for their jwt and
+    // needs to send it to our backend
+    return dynamicCookiesEnabled || byoJwtCookieEnabled;
+};
+const parseToken = (token) => {
+    var _a;
+    if (!token)
+        return undefined;
+    const base64 = (_a = token.split('.')[1]) === null || _a === void 0 ? void 0 : _a.replace(/-/g, '+').replace(/_/g, '/');
+    const jsonPayload = base64 &&
+        decodeURIComponent(atob(base64)
+            .split('')
+            .map((c) => `%${`00${c.charCodeAt(0).toString(16)}`.slice(-2)}`)
+            .join(''));
+    return JSON.parse(jsonPayload);
+};
+const decodeMinJwt = (token) => {
+    try {
+        const json = parseToken(token);
+        if (!json)
+            return undefined;
+        return sdkApiCore.MinifiedDynamicJwtFromJSON(json);
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+};
+const getMinAuthToken = () => {
+    var _a;
+    if (typeof window === 'undefined')
+        return undefined;
+    const token = (_a = utils.StorageService.getItem(AUTH_MIN_TOKEN, {
+        priority: ['secureStorage', 'localStorage'],
+    })) !== null && _a !== void 0 ? _a : utils.StorageService.getItem(AUTH_MIN_TOKEN_DEMO, {
+        priority: ['secureStorage', 'localStorage'],
+    });
+    if (!token || isMinAuthTokenExpired(token))
+        return undefined;
+    return token;
+};
+const isMinAuthTokenExpired = (token) => {
+    const decoded = decodeMinJwt(token);
+    return isTokenExpired(decoded);
+};
+const isTokenExpired = (decoded) => {
+    if (!decoded) {
+        return true;
+    }
+    if (!decoded.exp) {
+        return true;
+    }
+    const expirationTime = new Date(decoded.exp * 1000).getTime();
+    const currentTime = new Date().getTime();
+    if (currentTime >= expirationTime) {
+        return true;
+    }
+    return false;
+};
+
+exports.AUTH_MIN_TOKEN = AUTH_MIN_TOKEN;
+exports.AUTH_MIN_TOKEN_DEMO = AUTH_MIN_TOKEN_DEMO;
+exports.decodeMinJwt = decodeMinJwt;
+exports.getMinAuthToken = getMinAuthToken;
+exports.isCookieEnabled = isCookieEnabled;
+exports.isMinAuthTokenExpired = isMinAuthTokenExpired;
+exports.logger = logger;
+exports.parseToken = parseToken;