@dynamic-labs/embedded-wallet-solana 0.0.0-exp20240808.0

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.cjs

@@ -0,0 +1,374 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var webauthnStamper = require('@turnkey/webauthn-stamper');
+var http = require('@turnkey/http');
+var solana = require('@turnkey/solana');
+var iframeStamper = require('@turnkey/iframe-stamper');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var rpcProviderSolana = require('@dynamic-labs/rpc-provider-solana');
+var utils = require('@dynamic-labs/utils');
+var solanaUtils = require('@dynamic-labs/solana-utils');
+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 TurnkeySolanaSigner = require('./TurnkeySolanaSigner.cjs');
+
+class TurnkeySolanaWalletConnector extends embeddedWallet.TurnkeyWalletConnectorBase {
+    constructor(nameAndKey, props) {
+        var _a;
+        super(nameAndKey, props);
+        // Public fields
+        this.ChainWallet = walletConnectorCore.Wallet;
+        this.connectedChain = 'SOL';
+        this.supportedChains = ['SOL'];
+        this.verifiedCredentialChain = 'solana';
+        this.stampCreateWalletAccountRequest = (_b) => _tslib.__awaiter(this, [_b], void 0, function* ({ request, }) {
+            const turnkeyClient = this.getTurnkeyClient();
+            return turnkeyClient.stampCreateWalletAccounts(request);
+        });
+        this.solNetworks = props.solNetworks;
+        this.walletUiUtils = props.walletUiUtils;
+        this._turnkeyAccount = undefined;
+        this._connectionClient = undefined;
+        this.chainRpcProviders = props.chainRpcProviders;
+        (_a = this.chainRpcProviders) === null || _a === void 0 ? void 0 : _a.registerSolanaProviders();
+        this.__turnkeyClient = this.getTurnkeyClient();
+    }
+    getRpcUrl() {
+        var _a;
+        const [network] = this.solNetworks;
+        if (!network) {
+            throw new utils.DynamicError('No enabled networks');
+        }
+        return ((_a = network.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) || network.rpcUrls[0];
+    }
+    getConnection(commitmentOrConfig) {
+        if (!this._connectionClient) {
+            const rpcUrl = this.getRpcUrl();
+            if (!rpcUrl)
+                throw new utils.DynamicError('No rpcUrl');
+            this._connectionClient = createSolanaConnection.createSolanaConnection(rpcUrl, commitmentOrConfig);
+        }
+        return this._connectionClient;
+    }
+    getWalletClient() {
+        return this.getConnection();
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connection = this.getConnection();
+            let genesisHash = localStorage.getItem(getGenesisHashLSKey.getGenesisHashLSKey(connection.rpcEndpoint));
+            if (!genesisHash) {
+                genesisHash = yield connection.getGenesisHash();
+                localStorage.setItem(getGenesisHashLSKey.getGenesisHashLSKey(connection.rpcEndpoint), genesisHash);
+            }
+            genesisHash = genesisHash.substring(0, 32);
+            // see: https://github.com/ChainAgnostic/namespaces/blob/main/solana/caip2.md
+            if (genesisHash === '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp') {
+                return 'mainnet';
+            }
+            else if (genesisHash === 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1') {
+                return 'devnet';
+            }
+            else {
+                return 'testnet';
+            }
+        });
+    }
+    getPublicClient() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (this.solNetworks.length === 0)
+                return;
+            const configurations = {
+                cosmos: [],
+                evm: undefined,
+                solana: this.solNetworks,
+                starknet: undefined,
+            };
+            if (!this.chainRpcProviders)
+                return undefined;
+            const providers = this.chainRpcProviders.getProviders(configurations);
+            return (_a = this.chainRpcProviders.getSolanaProviderByChainId(providers, '101')) === null || _a === void 0 ? void 0 : _a.provider;
+        });
+    }
+    supportsNetworkSwitching() {
+        return false;
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        const turnkeyVerifiedCredential = embeddedWallet.findTurnkeyVerifiedCredential(verifiedCredentials, rpcProviderSolana.ProviderChain.SOLANA);
+        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredential) !==
+            JSON.stringify(turnkeyVerifiedCredential);
+        if (!didTurnkeyVerifiedCredentialsChanged) {
+            return;
+        }
+        this.verifiedCredential = turnkeyVerifiedCredential;
+        this.refreshTurnkeyAccount();
+    }
+    getAccount() {
+        return this.turnkeyAddress;
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(getGenesisHashLSKey.getGenesisHashLSKey(this.getRpcUrl()));
+        });
+    }
+    refreshTurnkeyAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            this._turnkeyAccount = undefined;
+            return this.getTurnkeyAccount();
+        });
+    }
+    getTurnkeyClient() {
+        var _a;
+        let rpId = utils.getTLD();
+        if (!rpId) {
+            rpId = utils.PlatformService.getHostname();
+        }
+        const passkeyStamper = embeddedWallet.PasskeyService.createWebauthnStamper({
+            rpId,
+        });
+        const apiKeyStamper = embeddedWallet.TurnkeyWalletConnectorBase === null || embeddedWallet.TurnkeyWalletConnectorBase === void 0 ? void 0 : embeddedWallet.TurnkeyWalletConnectorBase.apiKeyStamper;
+        const stamper = apiKeyStamper !== null && apiKeyStamper !== void 0 ? apiKeyStamper : passkeyStamper;
+        this.__turnkeyClient =
+            (_a = this.getAuthenticatorHandler().client) !== null && _a !== void 0 ? _a : new http.TurnkeyClient({
+                baseUrl: embeddedWallet.TURNKEY_API_BASE_URL,
+            }, stamper);
+        return this.__turnkeyClient;
+    }
+    createTurnkeyAccount(_a) {
+        return _tslib.__awaiter(this, arguments, void 0, function* ({ organizationId, }) {
+            const turnkeyClient = this.getTurnkeyClient();
+            const signer = new solana.TurnkeySigner({ client: turnkeyClient, organizationId });
+            return signer;
+        });
+    }
+    getTurnkeyAccount() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c, _d;
+            if (this._turnkeyAccount &&
+                ((this.getAuthenticatorHandler().recoveryType === 'passkey' &&
+                    ((_a = this.__turnkeyClient) === null || _a === void 0 ? void 0 : _a.stamper) instanceof webauthnStamper.WebauthnStamper) ||
+                    (this.getAuthenticatorHandler().recoveryType === 'email' &&
+                        ((_b = this.__turnkeyClient) === null || _b === void 0 ? void 0 : _b.stamper) instanceof iframeStamper.IframeStamper)) &&
+                this.__turnkeyClient === this.getAuthenticatorHandler().client) {
+                return this._turnkeyAccount;
+            }
+            const { turnkeySubOrganizationId } = (_c = this.walletProperties) !== null && _c !== void 0 ? _c : {};
+            const { address } = (_d = this.verifiedCredential) !== null && _d !== void 0 ? _d : {};
+            if (!turnkeySubOrganizationId || !address) {
+                return;
+            }
+            this._turnkeyAccount = yield this.createTurnkeyAccount({
+                organizationId: turnkeySubOrganizationId,
+            });
+            this.setLoggerMetadata();
+            return this._turnkeyAccount;
+        });
+    }
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return new TurnkeySolanaSigner.TurnkeySolanaSigner({ walletConnector: this });
+        });
+    }
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const connectionClient = this.getConnection();
+            const publicKey = new web3_js.PublicKey(address);
+            const balance = yield connectionClient.getBalance(publicKey);
+            const solBalance = this.lamportsToSol(balance);
+            return solBalance.toString();
+        });
+    }
+    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;
+            let signedMessageRaw;
+            yield this.createOrRestoreSession();
+            yield this.walletUiUtils.signMessage({
+                handler: () => _tslib.__awaiter(this, void 0, void 0, function* () {
+                    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: new TextDecoder().decode(encodedMessage),
+            });
+            if (!signedMessageRaw) {
+                throw new Error('Failed to sign message');
+            }
+            return signedMessageRaw;
+        });
+    }
+    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');
+            }
+            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) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.turnkeyAddress)
+                throw new utils.DynamicError('Solana wallet not found');
+            const currentConnection = this.getConnection('confirmed');
+            const blockhash = yield currentConnection.getLatestBlockhash();
+            if ('version' in transaction) {
+                transaction.message.recentBlockhash =
+                    blockhash.blockhash;
+            }
+            else {
+                transaction.recentBlockhash = blockhash.blockhash;
+                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(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(() => {
+                    reject(new utils.DynamicError('Transaction timed out'));
+                }, 60000);
+                currentConnection.onSignature(signature, (result) => {
+                    clearTimeout(timeout);
+                    if (result.err) {
+                        reject(new utils.DynamicError('Transaction failed'));
+                    }
+                    else {
+                        resolve(signature);
+                    }
+                }, 'confirmed');
+            });
+        });
+    }
+    signAndSendTransaction(transaction, options) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (!this.turnkeyAddress)
+                throw new utils.DynamicError('Solana wallet not found');
+            const transactionsData = yield transactionDecoder.decodeTransaction(transaction, 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);
+            }
+            catch (e) {
+                if (e.message === 'Insufficient funds') {
+                    insufficientFunds = true;
+                }
+            }
+            const to = transactionDecoder.summarizeTransactionDecodedData(transactionsData);
+            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,
+            });
+            uiTransaction.to = to;
+            uiTransaction.value = spent;
+            if (insufficientFunds) {
+                uiTransaction.notEnoughFundsError = true;
+            }
+            return this.walletUiUtils.sendTransaction(this, uiTransaction);
+        });
+    }
+    sendTransaction(transaction_1, connection_1) {
+        return _tslib.__awaiter(this, arguments, void 0, function* (transaction, connection, options = {}) {
+            var _a;
+            if (!this.turnkeyAddress)
+                throw new utils.DynamicError('Solana wallet not found');
+            if (!transaction || !connection) {
+                throw new utils.DynamicError('Transaction and connection are required');
+            }
+            const { signers } = options, sendOptions = _tslib.__rest(options, ["signers"]);
+            const blockhash = yield connection.getLatestBlockhash({
+                commitment: options.preflightCommitment,
+                minContextSlot: options.minContextSlot,
+            });
+            if ('version' in transaction) {
+                (signers === null || signers === void 0 ? void 0 : signers.length) && transaction.sign(signers);
+            }
+            else {
+                transaction.feePayer =
+                    transaction.feePayer || new web3_js.PublicKey(this.turnkeyAddress);
+                transaction.recentBlockhash =
+                    transaction.recentBlockhash || blockhash.blockhash;
+                (signers === null || signers === void 0 ? void 0 : signers.length) && transaction.partialSign(...signers);
+            }
+            sendOptions.preflightCommitment =
+                sendOptions.preflightCommitment || connection.commitment;
+            const signature = yield connection.sendRawTransaction(transaction.serialize(), options);
+            const transactionConfirmationStrategy = {
+                blockhash: blockhash.blockhash,
+                lastValidBlockHeight: blockhash.lastValidBlockHeight,
+                signature,
+            };
+            const result = yield (connection === null || connection === void 0 ? void 0 : connection.confirmTransaction(transactionConfirmationStrategy));
+            return ((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.err) ? JSON.stringify(result.value.err) : signature;
+        });
+    }
+    lamportsToSol(lamports) {
+        return lamports / web3_js.LAMPORTS_PER_SOL;
+    }
+    createUiTransaction(from) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return new solanaUtils.SolanaUiTransaction({
+                connection: this.getConnection(),
+                from,
+                onSubmit: (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction); }),
+            });
+        });
+    }
+}
+
+exports.TurnkeySolanaWalletConnector = TurnkeySolanaWalletConnector;

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

@@ -0,0 +1,58 @@
+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, Wallet, WalletConnector } 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 { TurnkeyWalletConnectorBase, TurnkeyWalletConnectorNameAndKey } from '@dynamic-labs/embedded-wallet';
+import { TurnkeySolanaSigner } from './TurnkeySolanaSigner';
+type SendTransactionOptions = ConfirmOptions & {
+    signers?: Signer[];
+};
+export type TurnkeySolanaConnectorProps = {
+    walletUiUtils: WalletUiUtils<WalletConnector>;
+    walletBook: WalletBookSchema;
+    solNetworks: GenericNetwork[];
+    appName?: string;
+    chainRpcProviders: IChainRpcProviders;
+};
+export declare class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase implements ISendBalanceWalletConnector {
+    ChainWallet: typeof Wallet;
+    connectedChain: Chain;
+    supportedChains: Chain[];
+    solNetworks: GenericNetwork[];
+    verifiedCredentialChain: string;
+    private walletUiUtils;
+    private _turnkeyAccount;
+    private _connectionClient;
+    private __turnkeyClient;
+    constructor(nameAndKey: TurnkeyWalletConnectorNameAndKey, props: TurnkeySolanaConnectorProps);
+    getRpcUrl(): string;
+    getConnection(commitmentOrConfig?: Commitment | ConnectionConfig): Connection;
+    getWalletClient(): Connection;
+    getNetwork(): Promise<string>;
+    getPublicClient(): Promise<Connection | undefined>;
+    supportsNetworkSwitching(): boolean;
+    setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    getAccount(): string | undefined;
+    endSession(): Promise<void>;
+    private refreshTurnkeyAccount;
+    private getTurnkeyClient;
+    private createTurnkeyAccount;
+    private getTurnkeyAccount;
+    getSigner(): Promise<TurnkeySolanaSigner | undefined>;
+    getBalance(address: string): Promise<string | undefined>;
+    signUint8ArrayMessage(encodedMessage: Uint8Array): Promise<Uint8Array>;
+    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>;
+    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 {};