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

package/CHANGELOG.md

@@ -1,4 +1,34 @@
 
+## [3.0.0-alpha.43](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.42...v3.0.0-alpha.43) (2024-08-15)
+
+
+### ⚠ BREAKING CHANGES
+
+* removes walletConnector from dynamic context (#6579)
+* removed deprecated props from user profile (#6589)
+
+### Features
+
+* optimize solana embedded transactions ([#6582](https://github.com/dynamic-labs/DynamicAuth/issues/6582)) ([419aff9](https://github.com/dynamic-labs/DynamicAuth/commit/419aff96d312892d7db520e94ecc6956b8de771d))
+
+
+### Bug Fixes
+
+* check if wallet is connected using normalized addresses ([#6594](https://github.com/dynamic-labs/DynamicAuth/issues/6594)) ([44aabae](https://github.com/dynamic-labs/DynamicAuth/commit/44aabae8ee72261bf0f7e308ed4adf0f42760ed2))
+* minor sdk ui updates ([#6590](https://github.com/dynamic-labs/DynamicAuth/issues/6590)) ([8619e40](https://github.com/dynamic-labs/DynamicAuth/commit/8619e40e1afff8d68357138f3b5b9b89989140fd))
+
+
+* removed deprecated props from user profile ([#6589](https://github.com/dynamic-labs/DynamicAuth/issues/6589)) ([b621da8](https://github.com/dynamic-labs/DynamicAuth/commit/b621da8a0703eb8228a5b10131af2717f314fd2e))
+* removes walletConnector from dynamic context ([#6579](https://github.com/dynamic-labs/DynamicAuth/issues/6579)) ([51d69fe](https://github.com/dynamic-labs/DynamicAuth/commit/51d69feebab71158ad2aa69f11001623a0aaa80a))
+
+## [3.0.0-alpha.42](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.41...v3.0.0-alpha.42) (2024-08-14)
+
+
+### Bug Fixes
+
+* isEmbeddedWallet condition in AuthProviderIcon ([#6581](https://github.com/dynamic-labs/DynamicAuth/issues/6581)) ([afe33ab](https://github.com/dynamic-labs/DynamicAuth/commit/afe33aba1cc8abefd0566bf4e9c0a4f199d64ef7))
+* update text on MFA backup codes acknowledgement ([#6559](https://github.com/dynamic-labs/DynamicAuth/issues/6559)) ([98b5475](https://github.com/dynamic-labs/DynamicAuth/commit/98b5475df73039061d593318cb26140075de69e1))
+
 ## [3.0.0-alpha.41](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.40...v3.0.0-alpha.41) (2024-08-13)
 
 ## [3.0.0-alpha.40](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.39...v3.0.0-alpha.40) (2024-08-13)

package/package.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "3.0.0-alpha.43";
+var dependencies = {
+	"@dynamic-labs/sdk-api-core": "0.0.516",
+	"@dynamic-labs/utils": "3.0.0-alpha.43",
+	"@dynamic-labs/logger": "3.0.0-alpha.43",
+	"@dynamic-labs/types": "3.0.0-alpha.43",
+	eventemitter3: "5.0.1",
+	"@solana/spl-token": "0.4.6",
+	"@solana/web3.js": "1.92.1",
+	"@turnkey/http": "2.7.1",
+	"@turnkey/iframe-stamper": "2.0.0",
+	"@turnkey/solana": "0.3.1",
+	"@turnkey/webauthn-stamper": "0.5.0"
+};
+
+exports.dependencies = dependencies;
+exports.version = version;

package/package.js

@@ -0,0 +1,17 @@
+'use client'
+var version = "3.0.0-alpha.43";
+var dependencies = {
+	"@dynamic-labs/sdk-api-core": "0.0.516",
+	"@dynamic-labs/utils": "3.0.0-alpha.43",
+	"@dynamic-labs/logger": "3.0.0-alpha.43",
+	"@dynamic-labs/types": "3.0.0-alpha.43",
+	eventemitter3: "5.0.1",
+	"@solana/spl-token": "0.4.6",
+	"@solana/web3.js": "1.92.1",
+	"@turnkey/http": "2.7.1",
+	"@turnkey/iframe-stamper": "2.0.0",
+	"@turnkey/solana": "0.3.1",
+	"@turnkey/webauthn-stamper": "0.5.0"
+};
+
+export { dependencies, version };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/embedded-wallet-solana",
-  "version": "3.0.0-alpha.41",
+  "version": "3.0.0-alpha.43",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -26,21 +26,24 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@dynamic-labs/sdk-api-core": "0.0.510",
+    "@dynamic-labs/sdk-api-core": "0.0.516",
+    "@dynamic-labs/utils": "3.0.0-alpha.43",
+    "@dynamic-labs/logger": "3.0.0-alpha.43",
+    "@dynamic-labs/types": "3.0.0-alpha.43",
+    "eventemitter3": "5.0.1",
     "@solana/spl-token": "0.4.6",
     "@solana/web3.js": "1.92.1",
     "@turnkey/http": "2.7.1",
     "@turnkey/iframe-stamper": "2.0.0",
     "@turnkey/solana": "0.3.1",
     "@turnkey/webauthn-stamper": "0.5.0",
-    "@dynamic-labs/embedded-wallet": "3.0.0-alpha.41",
-    "@dynamic-labs/rpc-provider-solana": "3.0.0-alpha.41",
-    "@dynamic-labs/rpc-providers": "3.0.0-alpha.41",
-    "@dynamic-labs/solana-utils": "3.0.0-alpha.41",
-    "@dynamic-labs/types": "3.0.0-alpha.41",
-    "@dynamic-labs/utils": "3.0.0-alpha.41",
-    "@dynamic-labs/wallet-book": "3.0.0-alpha.41",
-    "@dynamic-labs/wallet-connector-core": "3.0.0-alpha.41",
+    "@dynamic-labs/embedded-wallet": "3.0.0-alpha.43",
+    "@dynamic-labs/rpc-provider-solana": "3.0.0-alpha.43",
+    "@dynamic-labs/rpc-providers": "3.0.0-alpha.43",
+    "@dynamic-labs/solana-utils": "3.0.0-alpha.43",
+    "@dynamic-labs/wallet-book": "3.0.0-alpha.43",
+    "@dynamic-labs/wallet-connector-core": "3.0.0-alpha.43",
+    "react-dom": "18.2.0",
     "viem": "2.9.25"
   },
   "peerDependencies": {}

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.cjs

@@ -16,6 +16,7 @@ var embeddedWallet = require('@dynamic-labs/embedded-wallet');
 var createSolanaConnection = require('../utils/createSolanaConnection/createSolanaConnection.cjs');
 var getGenesisHashLSKey = require('../utils/getGenesisHashLSKey/getGenesisHashLSKey.cjs');
 var transactionDecoder = require('../utils/transactionDecoder/transactionDecoder.cjs');
+var api = require('../utils/api/api.cjs');
 var TurnkeySolanaSigner = require('./TurnkeySolanaSigner.cjs');
 
 class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnectorBase {
@@ -26,6 +27,23 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
         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) => _tslib.__awaiter(this, [_b], void 0, function* ({ request, }) {
             const turnkeyClient = this.getTurnkeyClient();
             return turnkeyClient.stampCreateWalletAccounts(request);
@@ -289,16 +307,26 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
     }
     signAndSendTransaction(transaction, options) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.turnkeyAddress)
                 throw new utils.DynamicError('Solana wallet not found');
-            const transactionsData = yield transactionDecoder.decodeTransaction(transaction, this.getConnection(), this.turnkeyAddress);
+            let optimizedTransaction = transaction;
+            try {
+                if ((yield this.getNetwork()) === 'mainnet') {
+                    optimizedTransaction = (yield api.optimizeSolanaTransaction(this.getEnvId(), transaction, (_a = this.turnkeyAddress) !== null && _a !== void 0 ? _a : ''));
+                }
+            }
+            catch (e) {
+                embeddedWallet.logger.warn('Failed to optimize transaction', e);
+            }
+            const transactionsData = yield transactionDecoder.decodeTransaction(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
             if (!(transactionsData === null || transactionsData === void 0 ? void 0 : transactionsData.length)) {
                 throw new utils.DynamicError('Incorrectly formatted transaction instructions');
             }
             let spent;
             let insufficientFunds = false;
             try {
-                spent = yield transactionDecoder.getTotalSolanaSpend(transaction, this.getConnection(), this.turnkeyAddress);
+                spent = yield transactionDecoder.getTotalSolanaSpend(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
             }
             catch (e) {
                 if (e.message === 'Insufficient funds') {
@@ -309,8 +337,8 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
             const uiTransaction = new solanaUtils.SolanaUiTransaction({
                 connection: this.getConnection(),
                 from: this.turnkeyAddress,
-                onSubmit: () => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction, options); }),
-                originalTransaction: transaction,
+                onSubmit: () => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(optimizedTransaction, options); }),
+                originalTransaction: optimizedTransaction,
             });
             uiTransaction.to = to;
             uiTransaction.value = spent;

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.d.ts

@@ -43,6 +43,7 @@ export declare class TurnkeySolanaWalletConnector extends TurnkeyWalletConnector
     getSigner(): Promise<TurnkeySolanaSigner | undefined>;
     getBalance(address: string): Promise<string | undefined>;
     signUint8ArrayMessage(encodedMessage: Uint8Array): Promise<Uint8Array>;
+    getEnvId: () => any;
     signMessage(messageToSign: string): Promise<string | undefined>;
     signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
     internalSignAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<string>;

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.js

@@ -12,6 +12,7 @@ import { TurnkeyWalletConnectorBase, findTurnkeyVerifiedCredential, PasskeyServi
 import { createSolanaConnection } from '../utils/createSolanaConnection/createSolanaConnection.js';
 import { getGenesisHashLSKey } from '../utils/getGenesisHashLSKey/getGenesisHashLSKey.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 {
@@ -22,6 +23,23 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
         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, }) {
             const turnkeyClient = this.getTurnkeyClient();
             return turnkeyClient.stampCreateWalletAccounts(request);
@@ -285,16 +303,26 @@ 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');
             }
             let spent;
             let insufficientFunds = false;
             try {
-                spent = yield getTotalSolanaSpend(transaction, this.getConnection(), this.turnkeyAddress);
+                spent = yield getTotalSolanaSpend(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
             }
             catch (e) {
                 if (e.message === 'Insufficient funds') {
@@ -305,8 +333,8 @@ class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
             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 = spent;

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.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var EventEmitter = require('eventemitter3');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
+
+const dynamicEvents = new EventEmitter__default["default"]();
+
+exports.dynamicEvents = dynamicEvents;

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/DynamicEvents.js

@@ -0,0 +1,6 @@
+'use client'
+import EventEmitter from 'eventemitter3';
+
+const dynamicEvents = new EventEmitter();
+
+export { dynamicEvents };

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

@@ -0,0 +1,51 @@
+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;
+    /** This event is used to trigger logout to be called, DO NOT listen to it. Listen to "logout" instead */
+    triggerLogout: () => 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/LocalStorage.cjs

@@ -0,0 +1,81 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var DynamicEvents = require('../events/DynamicEvents.cjs');
+var helpers = require('./helpers.cjs');
+
+const AUTH_TOKEN = 'dynamic_authentication_token';
+class LocalStorage {
+    static getDynamicLSKey(key) {
+        return `${key}${LocalStorage.getSuffix()}`;
+    }
+    static validateRequest(key, fromAuxiliaryAuthFunctions) {
+        if (key === AUTH_TOKEN && !fromAuxiliaryAuthFunctions) {
+            throw new Error('You cannot access AUTH_TOKEN through localStorage. Use getAuthToken/ storeAuthToken helper functions instead');
+        }
+    }
+    static setSuffix(localStorageSuffix) {
+        if (!LocalStorage.__suffix__) {
+            const suffix = (localStorageSuffix && `_${localStorageSuffix}`) || '';
+            LocalStorage.__suffix__ = suffix;
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS(key, getAuth = false) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        LocalStorage.validateRequest(key, getAuth);
+        const value = window.localStorage.getItem(LocalStorage.getDynamicLSKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            helpers.logger.debug(`Error while parsing ${key} from local storage`, { value });
+            LocalStorage.removeFromLS(key);
+            DynamicEvents.dynamicEvents.emit('triggerLogout');
+        }
+        return undefined;
+    }
+    static removeFromLS(key) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        return window.localStorage.removeItem(LocalStorage.getDynamicLSKey(key));
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS(key, value, storeAuth = false) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        LocalStorage.validateRequest(key, storeAuth);
+        window.localStorage.setItem(LocalStorage.getDynamicLSKey(key), JSON.stringify(value));
+    }
+    static getKeys() {
+        if (typeof window === 'undefined') {
+            return [];
+        }
+        return Object.keys(window.localStorage);
+    }
+}
+LocalStorage.getSuffix = () => LocalStorage.__suffix__ || '';
+
+exports.AUTH_TOKEN = AUTH_TOKEN;
+exports.LocalStorage = LocalStorage;
+exports["default"] = LocalStorage;

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

@@ -0,0 +1,26 @@
+export declare const AUTH_TOKEN = "dynamic_authentication_token";
+export declare class LocalStorage {
+    private static __suffix__;
+    static getSuffix: () => string;
+    private static getDynamicLSKey;
+    private static validateRequest;
+    static setSuffix(localStorageSuffix?: string): void;
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS<T = any>(key: string, getAuth?: boolean): T | undefined;
+    static removeFromLS(key: string): void;
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS<T = any>(key: string, value: T, storeAuth?: boolean): void;
+    static getKeys(): string[];
+}
+export default LocalStorage;

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

@@ -0,0 +1,75 @@
+'use client'
+import { dynamicEvents } from '../events/DynamicEvents.js';
+import { logger } from './helpers.js';
+
+const AUTH_TOKEN = 'dynamic_authentication_token';
+class LocalStorage {
+    static getDynamicLSKey(key) {
+        return `${key}${LocalStorage.getSuffix()}`;
+    }
+    static validateRequest(key, fromAuxiliaryAuthFunctions) {
+        if (key === AUTH_TOKEN && !fromAuxiliaryAuthFunctions) {
+            throw new Error('You cannot access AUTH_TOKEN through localStorage. Use getAuthToken/ storeAuthToken helper functions instead');
+        }
+    }
+    static setSuffix(localStorageSuffix) {
+        if (!LocalStorage.__suffix__) {
+            const suffix = (localStorageSuffix && `_${localStorageSuffix}`) || '';
+            LocalStorage.__suffix__ = suffix;
+        }
+    }
+    /**
+     *
+     * @param key
+     * @param getAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static getFromLS(key, getAuth = false) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        LocalStorage.validateRequest(key, getAuth);
+        const value = window.localStorage.getItem(LocalStorage.getDynamicLSKey(key));
+        if (!value) {
+            return undefined;
+        }
+        try {
+            return JSON.parse(value);
+        }
+        catch (error) {
+            logger.debug(`Error while parsing ${key} from local storage`, { value });
+            LocalStorage.removeFromLS(key);
+            dynamicEvents.emit('triggerLogout');
+        }
+        return undefined;
+    }
+    static removeFromLS(key) {
+        if (typeof window === 'undefined') {
+            return undefined;
+        }
+        return window.localStorage.removeItem(LocalStorage.getDynamicLSKey(key));
+    }
+    /**
+     *
+     * @param key
+     * @param value
+     * @param storeAuth - verifies if the request to get AUTH_TOKEN is comming from getAuthToken and not directly
+     * @returns
+     */
+    static setToLS(key, value, storeAuth = false) {
+        if (typeof window === 'undefined') {
+            return;
+        }
+        LocalStorage.validateRequest(key, storeAuth);
+        window.localStorage.setItem(LocalStorage.getDynamicLSKey(key), JSON.stringify(value));
+    }
+    static getKeys() {
+        if (typeof window === 'undefined') {
+            return [];
+        }
+        return Object.keys(window.localStorage);
+    }
+}
+LocalStorage.getSuffix = () => LocalStorage.__suffix__ || '';
+
+export { AUTH_TOKEN, LocalStorage, LocalStorage 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-preprod.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-preprod.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,88 @@
+'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 LocalStorage = require('./LocalStorage.cjs');
+
+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 = LocalStorage.LocalStorage.getFromLS('dynamic_store')) !== null && _a !== void 0 ? _a : LocalStorage.LocalStorage.getFromLS('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 = LocalStorage.LocalStorage.getFromLS(AUTH_MIN_TOKEN, true)) !== null && _a !== void 0 ? _a : LocalStorage.LocalStorage.getFromLS(AUTH_MIN_TOKEN_DEMO, true);
+    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;

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

@@ -0,0 +1,12 @@
+import { MinifiedDynamicJwt } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+export declare const logger: Logger;
+export declare const AUTH_MIN_TOKEN = "dynamic_min_authentication_token";
+export declare const AUTH_MIN_TOKEN_DEMO = "dynamic_min_authentication_token_demo";
+export declare const DYNAMIC_STORE_DEMO = "dynamic_store_demo";
+export declare const DYNAMIC_STORE = "dynamic_store";
+export declare const isCookieEnabled: () => any;
+export declare const parseToken: (token: string | null | undefined) => any;
+export declare const decodeMinJwt: (token: string | null | undefined) => Omit<MinifiedDynamicJwt, 'jwt'> | undefined;
+export declare const getMinAuthToken: () => any;
+export declare const isMinAuthTokenExpired: (token: string) => boolean;

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

@@ -0,0 +1,77 @@
+'use client'
+import { AuthStorageEnum, MinifiedDynamicJwtFromJSON } from '@dynamic-labs/sdk-api-core';
+import { Logger } from '@dynamic-labs/logger';
+import { LocalStorage } from './LocalStorage.js';
+
+const logger = new 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 = LocalStorage.getFromLS('dynamic_store')) !== null && _a !== void 0 ? _a : LocalStorage.getFromLS('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(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 MinifiedDynamicJwtFromJSON(json);
+    }
+    catch (e) {
+        logger.error(e);
+        return undefined;
+    }
+};
+const getMinAuthToken = () => {
+    var _a;
+    if (typeof window === 'undefined')
+        return undefined;
+    const token = (_a = LocalStorage.getFromLS(AUTH_MIN_TOKEN, true)) !== null && _a !== void 0 ? _a : LocalStorage.getFromLS(AUTH_MIN_TOKEN_DEMO, true);
+    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;
+};
+
+export { AUTH_MIN_TOKEN, AUTH_MIN_TOKEN_DEMO, decodeMinJwt, getMinAuthToken, isCookieEnabled, isMinAuthTokenExpired, logger, parseToken };

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

@@ -0,0 +1,12 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _package = require('../../../../../package.cjs');
+
+const VERSION = _package.version;
+const API_VERSION = _package.dependencies['@dynamic-labs/sdk-api-core'];
+
+exports.API_VERSION = API_VERSION;
+exports.VERSION = VERSION;

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

@@ -0,0 +1,2 @@
+export declare const VERSION: string;
+export declare const API_VERSION: string;

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

@@ -0,0 +1,7 @@
+'use client'
+import { version, dependencies } from '../../../../../package.js';
+
+const VERSION = version;
+const API_VERSION = dependencies['@dynamic-labs/sdk-api-core'];
+
+export { API_VERSION, VERSION };