@dynamic-labs/embedded-wallet-solana 3.0.0-alpha.10

package/src/lib/TurnkeySolanaWalletConnector/TurnkeySolanaWalletConnector.js

@@ -0,0 +1,332 @@
+'use client'
+import { __awaiter, __rest } from '../../../_virtual/_tslib.js';
+import { LAMPORTS_PER_SOL, PublicKey } from '@solana/web3.js';
+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 { 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 { createSolanaConnection } from '../utils/createSolanaConnection/createSolanaConnection.js';
+import { getGenesisHashLSKey } from '../utils/getGenesisHashLSKey/getGenesisHashLSKey.js';
+import { decodeTransaction, getTotalSolanaSpend, summarizeTransactionDecodedData } from '../utils/transactionDecoder/transactionDecoder.js';
+import { TurnkeySolanaSigner } from './TurnkeySolanaSigner.js';
+
+class TurnkeySolanaWalletConnector extends TurnkeyWalletConnectorBase {
+    constructor(nameAndKey, props) {
+        var _a;
+        super(nameAndKey, props);
+        // Public fields
+        this.connectedChain = 'SOL';
+        this.supportedChains = ['SOL'];
+        this.verifiedCredentialChain = 'solana';
+        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 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 DynamicError('No rpcUrl');
+            this._connectionClient = createSolanaConnection(rpcUrl, commitmentOrConfig);
+        }
+        return this._connectionClient;
+    }
+    getWalletClient() {
+        return this.getConnection();
+    }
+    getNetwork() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = this.getConnection();
+            let genesisHash = localStorage.getItem(getGenesisHashLSKey(connection.rpcEndpoint));
+            if (!genesisHash) {
+                genesisHash = yield connection.getGenesisHash();
+                localStorage.setItem(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 __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 = findTurnkeyVerifiedCredential(verifiedCredentials, 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 __awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(getGenesisHashLSKey(this.getRpcUrl()));
+        });
+    }
+    refreshTurnkeyAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._turnkeyAccount = undefined;
+            return this.getTurnkeyAccount();
+        });
+    }
+    getTurnkeyClient() {
+        var _a;
+        let rpId = getTLD();
+        if (!rpId) {
+            rpId = PlatformService.getHostname();
+        }
+        const passkeyStamper = PasskeyService.createWebauthnStamper({
+            rpId,
+        });
+        const apiKeyStamper = TurnkeyWalletConnectorBase === null || TurnkeyWalletConnectorBase === void 0 ? void 0 : TurnkeyWalletConnectorBase.apiKeyStamper;
+        const stamper = apiKeyStamper !== null && apiKeyStamper !== void 0 ? apiKeyStamper : passkeyStamper;
+        this.__turnkeyClient =
+            (_a = this.getAuthenticatorHandler().client) !== null && _a !== void 0 ? _a : new TurnkeyClient({
+                baseUrl: TURNKEY_API_BASE_URL,
+            }, stamper);
+        return this.__turnkeyClient;
+    }
+    createTurnkeyAccount(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ organizationId, }) {
+            const turnkeyClient = this.getTurnkeyClient();
+            const signer = new TurnkeySigner({ client: turnkeyClient, organizationId });
+            return signer;
+        });
+    }
+    getTurnkeyAccount() {
+        return __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) ||
+                    (this.getAuthenticatorHandler().recoveryType === 'email' &&
+                        ((_b = this.__turnkeyClient) === null || _b === void 0 ? void 0 : _b.stamper) instanceof 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,
+            });
+            return this._turnkeyAccount;
+        });
+    }
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isSessionKeyCompatible()) {
+                yield this.createOrRestoreSession();
+            }
+            return new TurnkeySolanaSigner({ walletConnector: this });
+        });
+    }
+    getBalance() {
+        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);
+            const solBalance = this.lamportsToSol(balance);
+            return solBalance.toString();
+        });
+    }
+    signMessage(messageToSign) {
+        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({
+                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));
+                    return bufferToBase64(signedMessageRaw || Buffer.from([]));
+                }),
+                message: messageToSign,
+            });
+            return signedMessage;
+        });
+    }
+    signTransaction(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ transaction, }) {
+            const 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());
+        });
+    }
+    internalSignAndSendTransaction(transaction, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.turnkeyAddress)
+                throw new 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 PublicKey(this.turnkeyAddress);
+            }
+            const signedTransaction = yield this.signTransaction({ transaction });
+            const signature = yield currentConnection.sendRawTransaction(signedTransaction, options);
+            // listen for tx confirmation until 60 seconds, which is ~150 blocks expiration
+            return new Promise((resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    reject(new DynamicError('Transaction timed out'));
+                }, 60000);
+                currentConnection.onSignature(signature, (result) => {
+                    clearTimeout(timeout);
+                    if (result.err) {
+                        reject(new DynamicError('Transaction failed'));
+                    }
+                    else {
+                        resolve(signature);
+                    }
+                }, 'confirmed');
+            });
+        });
+    }
+    signAndSendTransaction(transaction, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.turnkeyAddress)
+                throw new DynamicError('Solana wallet not found');
+            const transactionsData = yield decodeTransaction(transaction, 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);
+            }
+            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,
+            });
+            uiTransaction.to = to;
+            uiTransaction.value = spent;
+            if (insufficientFunds) {
+                uiTransaction.notEnoughFundsError = true;
+            }
+            return this.walletUiUtils.sendTransaction(this, uiTransaction);
+        });
+    }
+    sendTransaction(transaction_1, connection_1) {
+        return __awaiter(this, arguments, void 0, function* (transaction, connection, options = {}) {
+            var _a;
+            if (!this.turnkeyAddress)
+                throw new DynamicError('Solana wallet not found');
+            if (!transaction || !connection) {
+                throw new DynamicError('Transaction and connection are required');
+            }
+            const { signers } = options, sendOptions = __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 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 / LAMPORTS_PER_SOL;
+    }
+    createUiTransaction(from) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new SolanaUiTransaction({
+                connection: this.getConnection(),
+                from,
+                onSubmit: (transaction) => __awaiter(this, void 0, void 0, function* () { return this.internalSignAndSendTransaction(transaction); }),
+            });
+        });
+    }
+}
+
+export { TurnkeySolanaWalletConnector };

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

@@ -0,0 +1 @@
+export { TurnkeySolanaWalletConnector } from './TurnkeySolanaWalletConnector';

package/src/lib/constants.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const SOLANA_GENESIS_HASH = 'genesis-hash';
+
+exports.SOLANA_GENESIS_HASH = SOLANA_GENESIS_HASH;

package/src/lib/constants.d.ts

@@ -0,0 +1 @@
+export declare const SOLANA_GENESIS_HASH = "genesis-hash";

package/src/lib/constants.js

@@ -0,0 +1,4 @@
+'use client'
+const SOLANA_GENESIS_HASH = 'genesis-hash';
+
+export { SOLANA_GENESIS_HASH };

package/src/lib/utils/createSolanaConnection/createSolanaConnection.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var web3_js = require('@solana/web3.js');
+
+const createSolanaConnection = (rpcUrl, commitmentOrConfig) => {
+    if (!rpcUrl)
+        throw new Error('rpcUrl is required');
+    return new web3_js.Connection(rpcUrl, commitmentOrConfig);
+};
+
+exports.createSolanaConnection = createSolanaConnection;

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

@@ -0,0 +1,2 @@
+import { Commitment, Connection, ConnectionConfig } from '@solana/web3.js';
+export declare const createSolanaConnection: (rpcUrl: string, commitmentOrConfig?: Commitment | ConnectionConfig) => Connection;

package/src/lib/utils/createSolanaConnection/createSolanaConnection.js

@@ -0,0 +1,10 @@
+'use client'
+import { Connection } from '@solana/web3.js';
+
+const createSolanaConnection = (rpcUrl, commitmentOrConfig) => {
+    if (!rpcUrl)
+        throw new Error('rpcUrl is required');
+    return new Connection(rpcUrl, commitmentOrConfig);
+};
+
+export { createSolanaConnection };

package/src/lib/utils/createSolanaConnection/index.d.ts

@@ -0,0 +1 @@
+export { createSolanaConnection } from './createSolanaConnection';

package/src/lib/utils/getGenesisHashLSKey/getGenesisHashLSKey.cjs

@@ -0,0 +1,10 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var constants = require('../../constants.cjs');
+
+const getGenesisHashLSKey = (rpcEndpoint) => `${rpcEndpoint}_${constants.SOLANA_GENESIS_HASH}`;
+
+exports.getGenesisHashLSKey = getGenesisHashLSKey;

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

@@ -0,0 +1 @@
+export declare const getGenesisHashLSKey: (rpcEndpoint: string) => string;

package/src/lib/utils/getGenesisHashLSKey/getGenesisHashLSKey.js

@@ -0,0 +1,6 @@
+'use client'
+import { SOLANA_GENESIS_HASH } from '../../constants.js';
+
+const getGenesisHashLSKey = (rpcEndpoint) => `${rpcEndpoint}_${SOLANA_GENESIS_HASH}`;
+
+export { getGenesisHashLSKey };

package/src/lib/utils/getGenesisHashLSKey/index.d.ts

@@ -0,0 +1 @@
+export { getGenesisHashLSKey } from './getGenesisHashLSKey';

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

@@ -0,0 +1,3 @@
+export { createSolanaConnection } from './createSolanaConnection';
+export { getGenesisHashLSKey } from './getGenesisHashLSKey';
+export { decodeTransaction, summarizeTransactionDecodedData, getTotalSolanaSpend, } from './transactionDecoder';

package/src/lib/utils/transactionDecoder/index.d.ts

@@ -0,0 +1 @@
+export { decodeTransaction, summarizeTransactionDecodedData, getTotalSolanaSpend, } from './transactionDecoder';

package/src/lib/utils/transactionDecoder/transactionDecoder.cjs

@@ -0,0 +1,140 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var splToken = require('@solana/spl-token');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+
+const getTotalSolanaSpend = (transaction, connection, thisAddress) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    let simulation;
+    if ('version' in transaction) {
+        simulation = yield connection.simulateTransaction(transaction, {
+            accounts: { addresses: [thisAddress], encoding: 'base64' },
+            replaceRecentBlockhash: true,
+        });
+    }
+    else {
+        simulation = yield connection.simulateTransaction(transaction, undefined, [new web3_js.PublicKey(thisAddress)]);
+    }
+    const previousBalance = yield connection.getBalance(new web3_js.PublicKey(thisAddress));
+    if (!((_c = (_b = (_a = simulation === null || simulation === void 0 ? void 0 : simulation.value) === null || _a === void 0 ? void 0 : _a.accounts) === null || _b === void 0 ? void 0 : _b[0]) === null || _c === void 0 ? void 0 : _c.lamports)) {
+        walletConnectorCore.logger.debug('Transaction simulation failed', simulation);
+        const instructionError = JSON.stringify({
+            InstructionError: [
+                0,
+                {
+                    Custom: 1,
+                },
+            ],
+        });
+        const insufficientFundsForRent = JSON.stringify({
+            InsufficientFundsForRent: {
+                account_index: 0,
+            },
+        });
+        if (JSON.stringify(simulation === null || simulation === void 0 ? void 0 : simulation.value.err) === instructionError ||
+            JSON.stringify(simulation === null || simulation === void 0 ? void 0 : simulation.value.err) === insufficientFundsForRent) {
+            throw new Error('Insufficient funds');
+        }
+        return undefined;
+    }
+    const totalSolTransfer = previousBalance - ((_f = (_e = (_d = simulation === null || simulation === void 0 ? void 0 : simulation.value) === null || _d === void 0 ? void 0 : _d.accounts) === null || _e === void 0 ? void 0 : _e[0]) === null || _f === void 0 ? void 0 : _f.lamports);
+    return BigInt(totalSolTransfer);
+});
+const decodeTransaction = (transaction, connection, thisAddress) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    var _g;
+    if (!transaction) {
+        throw new utils.DynamicError('Transaction is required');
+    }
+    let decodedInstructions = [];
+    if ('version' in transaction) {
+        const lookupTableAddresses = transaction.message.addressTableLookups.map((lookup) => new web3_js.PublicKey(lookup.accountKey));
+        // for NON simple sol transfers we need to fetch the lookup table accounts
+        if (lookupTableAddresses.length > 0) {
+            const lookupTables = yield Promise.all(lookupTableAddresses.map((address) => connection.getAddressLookupTable(address)));
+            const lookupTableAccounts = lookupTables
+                .filter((result) => result !== null)
+                .map((result) => result.value);
+            if (lookupTableAccounts.length > 0) {
+                decodedInstructions = web3_js.TransactionMessage.decompile(transaction.message, {
+                    addressLookupTableAccounts: lookupTableAccounts,
+                }).instructions;
+            }
+        }
+        else {
+            decodedInstructions = web3_js.TransactionMessage.decompile(transaction.message).instructions;
+        }
+    }
+    else if (!transaction.instructions) {
+        decodedInstructions = (_g = web3_js.Transaction.from(Buffer.from(transaction.serialize()))) === null || _g === void 0 ? void 0 : _g.instructions;
+    }
+    else {
+        decodedInstructions = transaction.instructions;
+    }
+    if (!(decodedInstructions === null || decodedInstructions === void 0 ? void 0 : decodedInstructions.length)) {
+        throw new utils.DynamicError('Bad formatted instruction');
+    }
+    const solTransfers = decodedInstructions.filter((instruction) => instruction.programId.equals(web3_js.SystemProgram.programId));
+    // non SPL transfers, just SOL
+    if (solTransfers.length > 0) {
+        return solTransfers.map((decodedInstruction) => {
+            const decodedTransferInstruction = web3_js.SystemInstruction.decodeTransfer(decodedInstruction);
+            return {
+                from: decodedTransferInstruction === null || decodedTransferInstruction === void 0 ? void 0 : decodedTransferInstruction.fromPubkey.toBase58(),
+                to: decodedTransferInstruction === null || decodedTransferInstruction === void 0 ? void 0 : decodedTransferInstruction.toPubkey.toBase58(),
+            };
+        });
+    }
+    // SPL transfers
+    return Promise.all(decodedInstructions.map((instruction) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+        var _h, _j, _k, _l, _m, _o, _p;
+        if (instruction.programId.equals(splToken.TOKEN_PROGRAM_ID)) {
+            const decodedTokenInstruction = splToken.decodeTransferInstructionUnchecked(instruction);
+            const { source, destination } = decodedTokenInstruction.keys;
+            if (destination) {
+                // for contract interactions, ex. swaps, the destination is the turnkey address, flip sender and receiver
+                if ((destination === null || destination === void 0 ? void 0 : destination.pubkey.toBase58()) === thisAddress) {
+                    return {
+                        from: thisAddress,
+                        to: source === null || source === void 0 ? void 0 : source.pubkey.toBase58(),
+                    };
+                }
+                // Pure SPL transfers, get the address from the destination token account to display to user
+                const destinationAccountInfo = yield connection.getParsedAccountInfo(destination.pubkey);
+                const isTokenAccount = ((_k = (_j = (_h = destinationAccountInfo.value) === null || _h === void 0 ? void 0 : _h.data) === null || _j === void 0 ? void 0 : _j.parsed) === null || _k === void 0 ? void 0 : _k.type) === 'account';
+                const destinationOwner = isTokenAccount
+                    ? (_p = (_o = (_m = (_l = destinationAccountInfo.value) === null || _l === void 0 ? void 0 : _l.data) === null || _m === void 0 ? void 0 : _m.parsed) === null || _o === void 0 ? void 0 : _o.info) === null || _p === void 0 ? void 0 : _p.owner
+                    : null;
+                const toAddress = destinationOwner
+                    ? destinationOwner
+                    : destination === null || destination === void 0 ? void 0 : destination.pubkey.toBase58();
+                return {
+                    from: thisAddress,
+                    to: toAddress,
+                };
+            }
+        }
+        return null;
+    })));
+});
+const summarizeTransactionDecodedData = (transactionsData) => {
+    const recipients = new Set();
+    transactionsData.forEach((transactionData) => {
+        if (transactionData && transactionData.to) {
+            recipients.add(transactionData.to);
+        }
+    });
+    const to = recipients.size === 1
+        ? recipients.values().next().value
+        : 'dyn_send_transaction.multiple_recipients';
+    return to;
+};
+
+exports.decodeTransaction = decodeTransaction;
+exports.getTotalSolanaSpend = getTotalSolanaSpend;
+exports.summarizeTransactionDecodedData = summarizeTransactionDecodedData;

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

@@ -0,0 +1,7 @@
+import { Transaction, VersionedTransaction, Connection } from '@solana/web3.js';
+export declare const getTotalSolanaSpend: (transaction: Transaction | VersionedTransaction, connection: Connection, thisAddress: string) => Promise<bigint | undefined>;
+export declare const decodeTransaction: (transaction: Transaction | VersionedTransaction, connection: Connection, thisAddress: string) => Promise<any>;
+export declare const summarizeTransactionDecodedData: (transactionsData: {
+    to: string;
+    from: string;
+}[]) => any;