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

package/package.cjs

@@ -0,0 +1,22 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var version = "3.0.1";
+var dependencies = {
+	"@dynamic-labs/sdk-api-core": "0.0.529",
+	"@dynamic-labs/utils": "3.0.1",
+	"@dynamic-labs/logger": "3.0.1",
+	"@dynamic-labs/types": "3.0.1",
+	eventemitter3: "5.0.1",
+	"@solana/spl-token": "0.4.6",
+	"@solana/web3.js": "1.92.1",
+	"@turnkey/http": "2.12.2",
+	"@turnkey/iframe-stamper": "2.0.0",
+	"@turnkey/solana": "0.3.9",
+	"@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.1";
+var dependencies = {
+	"@dynamic-labs/sdk-api-core": "0.0.529",
+	"@dynamic-labs/utils": "3.0.1",
+	"@dynamic-labs/logger": "3.0.1",
+	"@dynamic-labs/types": "3.0.1",
+	eventemitter3: "5.0.1",
+	"@solana/spl-token": "0.4.6",
+	"@solana/web3.js": "1.92.1",
+	"@turnkey/http": "2.12.2",
+	"@turnkey/iframe-stamper": "2.0.0",
+	"@turnkey/solana": "0.3.9",
+	"@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.9",
+  "version": "3.0.1",
   "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.470",
+    "@dynamic-labs/sdk-api-core": "0.0.529",
+    "@dynamic-labs/utils": "3.0.1",
+    "@dynamic-labs/logger": "3.0.1",
+    "@dynamic-labs/types": "3.0.1",
+    "eventemitter3": "5.0.1",
     "@solana/spl-token": "0.4.6",
     "@solana/web3.js": "1.92.1",
-    "@turnkey/http": "2.7.1",
+    "@turnkey/http": "2.12.2",
     "@turnkey/iframe-stamper": "2.0.0",
-    "@turnkey/solana": "0.3.1",
+    "@turnkey/solana": "0.3.9",
     "@turnkey/webauthn-stamper": "0.5.0",
-    "@dynamic-labs/embedded-wallet": "3.0.0-alpha.9",
-    "@dynamic-labs/rpc-provider-solana": "3.0.0-alpha.9",
-    "@dynamic-labs/rpc-providers": "3.0.0-alpha.9",
-    "@dynamic-labs/solana-utils": "3.0.0-alpha.9",
-    "@dynamic-labs/types": "3.0.0-alpha.9",
-    "@dynamic-labs/utils": "3.0.0-alpha.9",
-    "@dynamic-labs/wallet-book": "3.0.0-alpha.9",
-    "@dynamic-labs/wallet-connector-core": "3.0.0-alpha.9",
+    "@dynamic-labs/embedded-wallet": "3.0.1",
+    "@dynamic-labs/rpc-providers": "3.0.1",
+    "@dynamic-labs/solana-core": "3.0.1",
+    "@dynamic-labs/wallet-book": "3.0.1",
+    "@dynamic-labs/wallet-connector-core": "3.0.1",
+    "@dynamic-labs/webauthn": "3.0.1",
+    "react-dom": "18.2.0",
     "viem": "2.9.25"
   },
   "peerDependencies": {}

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaSigner.cjs

@@ -16,18 +16,15 @@ class TurnkeySolanaSigner {
             ? new web3_js.PublicKey(this.turnkeyAddress)
             : undefined;
     }
-    signMessage(message) {
+    signMessage(encodedMessage) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const signedMessage = yield this.walletConnector.signMessage(message);
-            if (!signedMessage) {
-                throw new Error('Failed to sign message');
-            }
-            return signedMessage;
+            const signedMessage = yield this.walletConnector.signUint8ArrayMessage(encodedMessage);
+            return { signature: signedMessage };
         });
     }
     signTransaction(transaction) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            return this.walletConnector.signTransaction({ transaction });
+            return this.walletConnector.signTransaction(transaction);
         });
     }
     signAllTransactions(

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

@@ -1,4 +1,5 @@
 import { PublicKey, SendOptions, Transaction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import { SignedMessage } from '@dynamic-labs/solana-core';
 import { TurnkeySolanaWalletConnector } from './TurnkeySolanaWalletConnector';
 export type IEmbeddedWalletSolanaSigner = {
     publicKey?: {
@@ -11,7 +12,7 @@ export type IEmbeddedWalletSolanaSigner = {
     signAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<{
         signature: TransactionSignature;
     }>;
-    signMessage(message: string, encoding?: string): Promise<string>;
+    signMessage(message: Uint8Array, encoding?: string): Promise<SignedMessage>;
     connect: (args?: {
         onlyIfTrusted: boolean;
     }) => Promise<{
@@ -29,10 +30,10 @@ export declare class TurnkeySolanaSigner implements IEmbeddedWalletSolanaSigner
     constructor({ walletConnector, }: {
         walletConnector: TurnkeySolanaWalletConnector;
     });
-    signMessage(message: string): Promise<string>;
-    signTransaction(transaction: Transaction | VersionedTransaction): Promise<any>;
-    signAllTransactions(_transactions: Array<Transaction | VersionedTransaction>): Promise<any>;
-    signAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: SendOptions): Promise<{
+    signMessage(encodedMessage: Uint8Array): Promise<SignedMessage>;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    signAllTransactions<T extends Transaction | VersionedTransaction>(_transactions: T[]): Promise<T[]>;
+    signAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<{
         signature: TransactionSignature;
     }>;
     connect(_args?: {

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaSigner.js

@@ -12,18 +12,15 @@ class TurnkeySolanaSigner {
             ? new PublicKey(this.turnkeyAddress)
             : undefined;
     }
-    signMessage(message) {
+    signMessage(encodedMessage) {
         return __awaiter(this, void 0, void 0, function* () {
-            const signedMessage = yield this.walletConnector.signMessage(message);
-            if (!signedMessage) {
-                throw new Error('Failed to sign message');
-            }
-            return signedMessage;
+            const signedMessage = yield this.walletConnector.signUint8ArrayMessage(encodedMessage);
+            return { signature: signedMessage };
         });
     }
     signTransaction(transaction) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.walletConnector.signTransaction({ transaction });
+            return this.walletConnector.signTransaction(transaction);
         });
     }
     signAllTransactions(

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.cjs

@@ -9,13 +9,13 @@ var webauthnStamper = require('@turnkey/webauthn-stamper');
 var http = require('@turnkey/http');
 var solana = require('@turnkey/solana');
 var iframeStamper = require('@turnkey/iframe-stamper');
-var rpcProviderSolana = require('@dynamic-labs/rpc-provider-solana');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
 var utils = require('@dynamic-labs/utils');
-var solanaUtils = require('@dynamic-labs/solana-utils');
+var solanaCore = require('@dynamic-labs/solana-core');
 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 {
@@ -23,9 +23,32 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
         var _a;
         super(nameAndKey, props);
         // Public fields
+        this.ChainWallet = solanaCore.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) => _tslib.__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;
@@ -57,10 +80,10 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
     getNetwork() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             const connection = this.getConnection();
-            let genesisHash = localStorage.getItem(getGenesisHashLSKey.getGenesisHashLSKey(connection.rpcEndpoint));
+            let genesisHash = localStorage.getItem(solanaCore.getGenesisHashLSKey(connection.rpcEndpoint));
             if (!genesisHash) {
                 genesisHash = yield connection.getGenesisHash();
-                localStorage.setItem(getGenesisHashLSKey.getGenesisHashLSKey(connection.rpcEndpoint), genesisHash);
+                localStorage.setItem(solanaCore.getGenesisHashLSKey(connection.rpcEndpoint), genesisHash);
             }
             genesisHash = genesisHash.substring(0, 32);
             // see: https://github.com/ChainAgnostic/namespaces/blob/main/solana/caip2.md
@@ -96,21 +119,38 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
         return false;
     }
     setVerifiedCredentials(verifiedCredentials) {
-        const turnkeyVerifiedCredential = embeddedWallet.findTurnkeyVerifiedCredential(verifiedCredentials, rpcProviderSolana.ProviderChain.SOLANA);
-        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredential) !==
-            JSON.stringify(turnkeyVerifiedCredential);
+        const turnkeyVerifiedCredentials = embeddedWallet.findTurnkeyVerifiedCredentials(verifiedCredentials, solanaCore.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 _tslib.__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 = walletConnectorCore.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 utils.DynamicError('Account not found');
+                }
+                this.verifiedCredential = targetActiveAccount;
+                this.refreshTurnkeyAccount();
+            }
+        });
+    }
     getAccount() {
         return this.turnkeyAddress;
     }
     endSession() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            localStorage.removeItem(getGenesisHashLSKey.getGenesisHashLSKey(this.getRpcUrl()));
+            localStorage.removeItem(solanaCore.getGenesisHashLSKey(this.getRpcUrl()));
         });
     }
     refreshTurnkeyAccount() {
@@ -162,23 +202,17 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
             this._turnkeyAccount = yield this.createTurnkeyAccount({
                 organizationId: turnkeySubOrganizationId,
             });
+            this.setLoggerMetadata();
             return this._turnkeyAccount;
         });
     }
     getSigner() {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            if (this.isSessionKeyCompatible()) {
-                yield this.createOrRestoreSession();
-            }
             return new TurnkeySolanaSigner.TurnkeySolanaSigner({ walletConnector: this });
         });
     }
-    getBalance() {
+    getBalance(address) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            const address = this.getAccount();
-            if (!address) {
-                return undefined;
-            }
             const connectionClient = this.getConnection();
             const publicKey = new web3_js.PublicKey(address);
             const balance = yield connectionClient.getBalance(publicKey);
@@ -186,34 +220,72 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
             return solBalance.toString();
         });
     }
-    signMessage(messageToSign) {
+    signUint8ArrayMessage(encodedMessage) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
             if (!this.turnkeyAddress) {
                 throw new utils.DynamicError('No turnkey account');
             }
             const address = this.turnkeyAddress;
-            const signedMessage = yield this.walletUiUtils.signMessage({
+            let signedMessageRaw;
+            yield this.createOrRestoreSession();
+            yield this.walletUiUtils.signMessage({
                 handler: () => _tslib.__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 utils.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 _tslib.__awaiter(this, arguments, void 0, function* ({ transaction, }) {
-            const account = yield this.getTurnkeyAccount();
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const enc = new TextEncoder();
+            const encodedMessage = enc.encode(messageToSign);
+            const signedRawMessage = yield this.signUint8ArrayMessage(encodedMessage);
+            return utils.bufferToBase64(signedRawMessage);
+        });
+    }
+    signTransaction(transaction) {
+        return _tslib.__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 (embeddedWallet.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 {
+                    embeddedWallet.logger.error('[TK] failed to perform SignTransaction activity', err);
+                    throw err;
+                }
+            }
+            return transaction;
         });
     }
     internalSignAndSendTransaction(transaction, options) {
@@ -232,8 +304,8 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
                 transaction.feePayer =
                     (_a = transaction.feePayer) !== null && _a !== void 0 ? _a : new web3_js.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(() => {
@@ -253,21 +325,45 @@ 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');
             }
-            const { to, value } = transactionDecoder.summarizeTransactionDecodedData(transactionsData);
-            const uiTransaction = new solanaUtils.SolanaUiTransaction({
+            let spent;
+            let insufficientFunds = false;
+            try {
+                spent = yield transactionDecoder.getTotalSolanaSpend(optimizedTransaction, this.getConnection(), this.turnkeyAddress);
+            }
+            catch (e) {
+                if (e.message === 'Insufficient funds') {
+                    insufficientFunds = true;
+                }
+            }
+            const to = transactionDecoder.summarizeTransactionDecodedData(transactionsData);
+            const uiTransaction = new solanaCore.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 = 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);
         });
     }
@@ -311,11 +407,14 @@ class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnector
     }
     createUiTransaction(from) {
         return _tslib.__awaiter(this, void 0, void 0, function* () {
-            return new solanaUtils.SolanaUiTransaction({
+            yield this.validateActiveWallet(from);
+            const transaction = new solanaCore.SolanaUiTransaction({
                 connection: this.getConnection(),
                 from,
                 onSubmit: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction); }),
             });
+            transaction.feeDeducted = true;
+            return transaction;
         });
     }
 }

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

@@ -1,23 +1,24 @@
-/// <reference types="node" />
 import { Commitment, Connection, ConnectionConfig, Transaction, VersionedTransaction, ConfirmOptions, Signer, SendOptions } from '@solana/web3.js';
+import { TurnkeyApiTypes } from '@turnkey/http';
 import { GenericNetwork, IUITransaction, WalletUiUtils } from '@dynamic-labs/types';
-import { Chain, ISendBalanceWalletConnector, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { Chain, ISendBalanceWalletConnector, InternalWalletConnector } from '@dynamic-labs/wallet-connector-core';
 import { WalletBookSchema } from '@dynamic-labs/wallet-book';
 import { JwtVerifiedCredential } from '@dynamic-labs/sdk-api-core';
-import { IChainRpcProviders } from '@dynamic-labs/rpc-provider-solana';
+import { IChainRpcProviders, SolanaWallet } from '@dynamic-labs/solana-core';
 import { TurnkeyWalletConnectorBase, TurnkeyWalletConnectorNameAndKey } from '@dynamic-labs/embedded-wallet';
 import { TurnkeySolanaSigner } from './TurnkeySolanaSigner';
 type SendTransactionOptions = ConfirmOptions & {
     signers?: Signer[];
 };
 export type TurnkeySolanaConnectorProps = {
-    walletUiUtils: WalletUiUtils<WalletConnector>;
+    walletUiUtils: WalletUiUtils<InternalWalletConnector>;
     walletBook: WalletBookSchema;
     solNetworks: GenericNetwork[];
     appName?: string;
     chainRpcProviders: IChainRpcProviders;
 };
 export declare class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase implements ISendBalanceWalletConnector {
+    ChainWallet: typeof SolanaWallet;
     connectedChain: Chain;
     supportedChains: Chain[];
     solNetworks: GenericNetwork[];
@@ -34,6 +35,7 @@ export declare class TurnkeySolanaWalletConnector extends TurnkeyWalletConnector
     getPublicClient(): Promise<Connection | undefined>;
     supportsNetworkSwitching(): boolean;
     setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    validateActiveWallet(expectedAddress: string): Promise<void>;
     getAccount(): string | undefined;
     endSession(): Promise<void>;
     private refreshTurnkeyAccount;
@@ -41,15 +43,18 @@ export declare class TurnkeySolanaWalletConnector extends TurnkeyWalletConnector
     private createTurnkeyAccount;
     private getTurnkeyAccount;
     getSigner(): Promise<TurnkeySolanaSigner | undefined>;
-    getBalance(): Promise<string | undefined>;
+    getBalance(address: string): Promise<string | undefined>;
+    signUint8ArrayMessage(encodedMessage: Uint8Array): Promise<Uint8Array>;
+    getEnvId: () => any;
     signMessage(messageToSign: string): Promise<string | undefined>;
-    signTransaction({ transaction, }: {
-        transaction: Transaction | VersionedTransaction;
-    }): Promise<Buffer>;
-    internalSignAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: SendOptions): Promise<string>;
-    signAndSendTransaction(transaction: Transaction | VersionedTransaction, options?: SendOptions): Promise<string>;
-    sendTransaction(transaction: Transaction | VersionedTransaction, connection: Connection, options?: SendTransactionOptions): Promise<string>;
+    signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T>;
+    internalSignAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<string>;
+    signAndSendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, options?: SendOptions): Promise<string>;
+    sendTransaction<T extends Transaction | VersionedTransaction>(transaction: T, connection: Connection, options?: SendTransactionOptions): Promise<string>;
     private lamportsToSol;
     createUiTransaction(from: string): Promise<IUITransaction>;
+    stampCreateWalletAccountRequest: ({ request, }: {
+        request: TurnkeyApiTypes['v1CreateWalletAccountsRequest'];
+    }) => Promise<import("@turnkey/http").TSignedRequest>;
 }
 export {};