@dynamic-labs/solana 0.0.0-exp20240808.0

package/src/solProviderHelper.cjs

@@ -0,0 +1,173 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var utils = require('@dynamic-labs/utils');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var isSignedMessage = require('./utils/isSignedMessage.cjs');
+var findWalletProviderFromWalletStandard = require('./utils/findWalletProviderFromWalletStandard/findWalletProviderFromWalletStandard.cjs');
+
+class SolProviderHelper {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    getInjectedConfig() {
+        if (!this.wallet || !this.wallet.injectedConfig)
+            return;
+        const { injectedConfig } = this.wallet;
+        return injectedConfig.find((c) => c.chain === 'sol');
+    }
+    getInstalledProvider() {
+        const config = this.getInjectedConfig();
+        if (!config || !config.extensionLocators) {
+            return undefined;
+        }
+        return this.installedProviderLookup(config.extensionLocators);
+    }
+    installedProviders() {
+        var _a, _b;
+        const config = this.getInjectedConfig();
+        if (!config)
+            return [];
+        const providers = [];
+        if (config.windowLocations) {
+            for (const windowLocation of config.windowLocations) {
+                const foundProviders = utils.getProvidersFromWindow(windowLocation);
+                if (foundProviders && foundProviders.length) {
+                    providers.push(...foundProviders);
+                }
+            }
+        }
+        // We should only include the `window.solana` provider
+        // when extensionLocators are provided
+        if (config.extensionLocators.length !== 0 && window.solana) {
+            if (!window.solana.providers) {
+                providers.push(window.solana);
+            }
+            else {
+                window.solana.providers.forEach((provider) => providers.push(provider));
+            }
+        }
+        if (((_b = (_a = config.walletStandardLocators) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+            const walletStandardProvider = findWalletProviderFromWalletStandard.findWalletProviderFromWalletStandard(config);
+            if (walletStandardProvider) {
+                providers.push(walletStandardProvider);
+            }
+        }
+        return providers;
+    }
+    installedProviderLookup(extensionLocators) {
+        const allInstalledProviders = this.installedProviders();
+        // No need to search through the window.solana providers if the
+        // wallet doesn't have extensionLocators
+        if (extensionLocators.length === 0) {
+            return allInstalledProviders[0];
+        }
+        return walletConnectorCore.ProviderLookup(allInstalledProviders, extensionLocators);
+    }
+    findProvider() {
+        return this.getInstalledProvider();
+    }
+    isInstalledHelper() {
+        return this.findProvider() !== undefined;
+    }
+    getAddress() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider = this.findProvider();
+            if (!provider) {
+                return undefined;
+            }
+            yield provider.connect();
+            return (_a = provider.publicKey) === null || _a === void 0 ? void 0 : _a.toString();
+        });
+    }
+    connect() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.findProvider();
+            if (!provider)
+                return undefined;
+            try {
+                if (!provider.isConnected) {
+                    yield provider.connect();
+                }
+                return provider;
+            }
+            catch (err) {
+                return undefined;
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.getAddress();
+            if (!walletAddress)
+                return undefined;
+            const provider = this.findProvider();
+            if (!provider)
+                return undefined;
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const signedMessage = yield provider.signMessage(encodedMessage, 'utf8');
+            if (!signedMessage)
+                return undefined;
+            return utils.bufferToBase64(isSignedMessage.isSignedMessage(signedMessage) ? signedMessage.signature : signedMessage);
+        });
+    }
+    handleAccountChange(walletConnector, web3Provider, address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!address) {
+                yield (web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.connect());
+                if ((_a = web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.publicKey) === null || _a === void 0 ? void 0 : _a.toString()) {
+                    walletConnector.emit('accountChange', {
+                        accounts: [web3Provider.publicKey.toString()],
+                    });
+                }
+                return;
+            }
+            if (address.toString()) {
+                walletConnector.emit('accountChange', { accounts: [address.toString()] });
+            }
+        });
+    }
+    _setupEventListeners(walletConnector) {
+        const provider = this.findProvider();
+        provider === null || provider === void 0 ? void 0 : provider.on('accountChanged', (publicKey) => this.handleAccountChange(walletConnector, provider, publicKey));
+        provider === null || provider === void 0 ? void 0 : provider.on('disconnect', () => walletConnector.emit('disconnect'));
+    }
+    _teardownEventListeners() {
+        const provider = this.findProvider();
+        if (!provider)
+            return;
+        provider.removeAllListeners();
+    }
+    getConnectedAccounts() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider = this.findProvider();
+            if (!provider)
+                return [];
+            let connectionResult;
+            try {
+                if (!provider.isConnected) {
+                    connectionResult = yield provider.connect({ onlyIfTrusted: true });
+                }
+            }
+            catch (e) {
+                return [];
+            }
+            const address = connectionResult === null || connectionResult === void 0 ? void 0 : connectionResult.address;
+            const publicKey = (_a = connectionResult === null || connectionResult === void 0 ? void 0 : connectionResult.publicKey) !== null && _a !== void 0 ? _a : (_b = provider.publicKey) === null || _b === void 0 ? void 0 : _b.toString();
+            if (address)
+                return [address];
+            else if (publicKey)
+                return [publicKey === null || publicKey === void 0 ? void 0 : publicKey.toString()];
+            else
+                return [];
+        });
+    }
+}
+
+exports.SolProviderHelper = SolProviderHelper;

package/src/solProviderHelper.d.ts

@@ -0,0 +1,36 @@
+import { WalletSchema } from '@dynamic-labs/wallet-book';
+import { ProviderCondition, WalletConnector } from '@dynamic-labs/wallet-connector-core';
+import { ISolana, ExtensionLocator as ExtensionLocator } from './types';
+export declare class SolProviderHelper {
+    private wallet;
+    constructor(wallet: WalletSchema);
+    getInjectedConfig(): {
+        chain: string;
+        extensionLocators: {
+            value: boolean;
+            flag: string;
+        }[];
+        providerInterface?: string | undefined;
+        walletStandard?: {
+            features: string[];
+            name: string;
+        } | undefined;
+        walletStandardLocators?: {
+            name: string;
+            locator: string;
+        }[] | undefined;
+        windowLocations?: string[] | undefined;
+    } | undefined;
+    getInstalledProvider(): ISolana | undefined;
+    installedProviders(): (import("./types").ISolanaSigner | import("./types").IBackpackSolanaSigner | import("./types").ICoinbaseSolanaSigner)[];
+    installedProviderLookup(extensionLocators: Array<ProviderCondition<ExtensionLocator>>): ISolana | undefined;
+    findProvider(): ISolana | undefined;
+    isInstalledHelper(): boolean;
+    getAddress(): Promise<string | undefined>;
+    connect(): Promise<ISolana | undefined>;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    handleAccountChange(walletConnector: WalletConnector, web3Provider: ISolana, address: string): Promise<void>;
+    _setupEventListeners(walletConnector: WalletConnector): void;
+    _teardownEventListeners(): void;
+    getConnectedAccounts(): Promise<string[]>;
+}

package/src/solProviderHelper.js

@@ -0,0 +1,169 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { getProvidersFromWindow, bufferToBase64 } from '@dynamic-labs/utils';
+import { ProviderLookup } from '@dynamic-labs/wallet-connector-core';
+import { isSignedMessage } from './utils/isSignedMessage.js';
+import { findWalletProviderFromWalletStandard } from './utils/findWalletProviderFromWalletStandard/findWalletProviderFromWalletStandard.js';
+
+class SolProviderHelper {
+    constructor(wallet) {
+        this.wallet = wallet;
+    }
+    getInjectedConfig() {
+        if (!this.wallet || !this.wallet.injectedConfig)
+            return;
+        const { injectedConfig } = this.wallet;
+        return injectedConfig.find((c) => c.chain === 'sol');
+    }
+    getInstalledProvider() {
+        const config = this.getInjectedConfig();
+        if (!config || !config.extensionLocators) {
+            return undefined;
+        }
+        return this.installedProviderLookup(config.extensionLocators);
+    }
+    installedProviders() {
+        var _a, _b;
+        const config = this.getInjectedConfig();
+        if (!config)
+            return [];
+        const providers = [];
+        if (config.windowLocations) {
+            for (const windowLocation of config.windowLocations) {
+                const foundProviders = getProvidersFromWindow(windowLocation);
+                if (foundProviders && foundProviders.length) {
+                    providers.push(...foundProviders);
+                }
+            }
+        }
+        // We should only include the `window.solana` provider
+        // when extensionLocators are provided
+        if (config.extensionLocators.length !== 0 && window.solana) {
+            if (!window.solana.providers) {
+                providers.push(window.solana);
+            }
+            else {
+                window.solana.providers.forEach((provider) => providers.push(provider));
+            }
+        }
+        if (((_b = (_a = config.walletStandardLocators) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0) {
+            const walletStandardProvider = findWalletProviderFromWalletStandard(config);
+            if (walletStandardProvider) {
+                providers.push(walletStandardProvider);
+            }
+        }
+        return providers;
+    }
+    installedProviderLookup(extensionLocators) {
+        const allInstalledProviders = this.installedProviders();
+        // No need to search through the window.solana providers if the
+        // wallet doesn't have extensionLocators
+        if (extensionLocators.length === 0) {
+            return allInstalledProviders[0];
+        }
+        return ProviderLookup(allInstalledProviders, extensionLocators);
+    }
+    findProvider() {
+        return this.getInstalledProvider();
+    }
+    isInstalledHelper() {
+        return this.findProvider() !== undefined;
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const provider = this.findProvider();
+            if (!provider) {
+                return undefined;
+            }
+            yield provider.connect();
+            return (_a = provider.publicKey) === null || _a === void 0 ? void 0 : _a.toString();
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const provider = this.findProvider();
+            if (!provider)
+                return undefined;
+            try {
+                if (!provider.isConnected) {
+                    yield provider.connect();
+                }
+                return provider;
+            }
+            catch (err) {
+                return undefined;
+            }
+        });
+    }
+    signMessage(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const walletAddress = yield this.getAddress();
+            if (!walletAddress)
+                return undefined;
+            const provider = this.findProvider();
+            if (!provider)
+                return undefined;
+            const encodedMessage = new TextEncoder().encode(messageToSign);
+            const signedMessage = yield provider.signMessage(encodedMessage, 'utf8');
+            if (!signedMessage)
+                return undefined;
+            return bufferToBase64(isSignedMessage(signedMessage) ? signedMessage.signature : signedMessage);
+        });
+    }
+    handleAccountChange(walletConnector, web3Provider, address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!address) {
+                yield (web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.connect());
+                if ((_a = web3Provider === null || web3Provider === void 0 ? void 0 : web3Provider.publicKey) === null || _a === void 0 ? void 0 : _a.toString()) {
+                    walletConnector.emit('accountChange', {
+                        accounts: [web3Provider.publicKey.toString()],
+                    });
+                }
+                return;
+            }
+            if (address.toString()) {
+                walletConnector.emit('accountChange', { accounts: [address.toString()] });
+            }
+        });
+    }
+    _setupEventListeners(walletConnector) {
+        const provider = this.findProvider();
+        provider === null || provider === void 0 ? void 0 : provider.on('accountChanged', (publicKey) => this.handleAccountChange(walletConnector, provider, publicKey));
+        provider === null || provider === void 0 ? void 0 : provider.on('disconnect', () => walletConnector.emit('disconnect'));
+    }
+    _teardownEventListeners() {
+        const provider = this.findProvider();
+        if (!provider)
+            return;
+        provider.removeAllListeners();
+    }
+    getConnectedAccounts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const provider = this.findProvider();
+            if (!provider)
+                return [];
+            let connectionResult;
+            try {
+                if (!provider.isConnected) {
+                    connectionResult = yield provider.connect({ onlyIfTrusted: true });
+                }
+            }
+            catch (e) {
+                return [];
+            }
+            const address = connectionResult === null || connectionResult === void 0 ? void 0 : connectionResult.address;
+            const publicKey = (_a = connectionResult === null || connectionResult === void 0 ? void 0 : connectionResult.publicKey) !== null && _a !== void 0 ? _a : (_b = provider.publicKey) === null || _b === void 0 ? void 0 : _b.toString();
+            if (address)
+                return [address];
+            else if (publicKey)
+                return [publicKey === null || publicKey === void 0 ? void 0 : publicKey.toString()];
+            else
+                return [];
+        });
+    }
+}
+
+export { SolProviderHelper };

package/src/solWalletConnector.cjs

@@ -0,0 +1,174 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../_virtual/_tslib.cjs');
+var web3_js = require('@solana/web3.js');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+var utils = require('@dynamic-labs/utils');
+var walletBook = require('@dynamic-labs/wallet-book');
+var extractNonce = require('./utils/extractNonce.cjs');
+var getGenesisHashLSKey = require('./utils/getGenesisHashLSKey.cjs');
+var SolanaWallet = require('./wallet/SolanaWallet.cjs');
+
+const MEMO_PROGRAM_ID = new web3_js.PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr');
+class SolWalletConnector extends walletConnectorCore.WalletConnectorBase {
+    constructor(opts) {
+        var _a;
+        super(opts);
+        this.isHardwareWalletEnabled = false;
+        this.verifiedCredentials = [];
+        this.ChainWallet = SolanaWallet.SolanaWallet;
+        this.supportedChains = ['SOL'];
+        this.connectedChain = 'SOL';
+        this.solNetworks = opts.solNetworks;
+        this.chainRpcProviders = opts.chainRpcProviders;
+        (_a = this.chainRpcProviders) === null || _a === void 0 ? void 0 : _a.registerSolanaProviders();
+    }
+    getNetwork() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const provider = this.getWalletClient();
+            let genesisHash = localStorage.getItem(getGenesisHashLSKey.getGenesisHashLSKey(provider.rpcEndpoint));
+            if (!genesisHash) {
+                genesisHash = yield provider.getGenesisHash();
+                localStorage.setItem(getGenesisHashLSKey.getGenesisHashLSKey(provider.rpcEndpoint), genesisHash);
+            }
+            genesisHash = genesisHash.substring(0, 32);
+            // see: https://github.com/ChainAgnostic/namespaces/blob/main/solana/caip2.md
+            let network;
+            if (genesisHash === '5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp') {
+                network = 'mainnet';
+            }
+            else if (genesisHash === 'EtWTRABZaYq6iMfeYKouRu166VU2xqa1') {
+                network = 'devnet';
+            }
+            else {
+                network = 'testnet';
+            }
+            return network;
+        });
+    }
+    endSession() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(getGenesisHashLSKey.getGenesisHashLSKey(this.getWalletClient().rpcEndpoint));
+        });
+    }
+    getWalletClient() {
+        var _a;
+        const [network] = this.solNetworks;
+        if (!network) {
+            throw new utils.DynamicError('No enabled networks');
+        }
+        const rpcUrl = ((_a = network.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) || network.rpcUrls[0];
+        return new web3_js.Connection(rpcUrl, 'confirmed');
+    }
+    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;
+        });
+    }
+    getBalance(address) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const publicKey = new web3_js.PublicKey(address);
+            const balance = this.lamportsToSol(yield this.getWalletClient().getBalance(publicKey));
+            return balance.toString();
+        });
+    }
+    // Solana uses lamports as the smallest unit of currency. This converts lamports to SOL.
+    lamportsToSol(lamports) {
+        return lamports / 1000000000;
+    }
+    canConnectWithHardwareWallet() {
+        const wallet = walletBook.findWalletBookWallet(this.walletBook, this.key);
+        if (!wallet || !wallet.hardwareWallets)
+            return false;
+        return wallet.hardwareWallets.includes('ledger');
+    }
+    signMessage(messageToSign) {
+        const _super = Object.create(null, {
+            signMessage: { get: () => super.signMessage }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.isHardwareWalletEnabled) {
+                throw new utils.NotSupportedError(`Message signing is currently not supported on ${this.name} hardware wallet.
+          You can use signMessageViaTransaction instead to achieve similar functionality
+          by signing a transaction with a memo instruction.
+          You can read more about it here https://github.com/solana-labs/solana/issues/21366`);
+            }
+            return _super.signMessage.call(this, messageToSign);
+        });
+    }
+    proveOwnership(messageToSign) {
+        const _super = Object.create(null, {
+            proveOwnership: { get: () => super.proveOwnership }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (this.isHardwareWalletEnabled) {
+                const nonce = extractNonce.extractNonce(messageToSign);
+                if (!nonce) {
+                    throw new utils.DynamicError('Nonce missing');
+                }
+                return this.signMessageViaTransaction(nonce);
+            }
+            return _super.proveOwnership.call(this, messageToSign);
+        });
+    }
+    signMessageViaTransaction(messageToSign) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            if (!address) {
+                throw new utils.DynamicError('Address missing');
+            }
+            const transaction = this.buildAuthTx(messageToSign);
+            transaction.feePayer = new web3_js.PublicKey(address);
+            transaction.recentBlockhash = (yield this.getWalletClient().getLatestBlockhash()).blockhash;
+            const signer = yield this.getSigner();
+            if (!signer) {
+                throw new utils.DynamicError('Signer not found');
+            }
+            const signedTransaction = yield signer.signTransaction(transaction);
+            const serializedSignedTransaction = signedTransaction.serialize();
+            /**
+             * Serializing the transaction and adding the type 'Buffer' is required
+             * when connecting with backpack + Ledger, because the returned object is not correctly
+             * serialized
+             */
+            return JSON.stringify({
+                signedTransaction: {
+                    data: Array.from(serializedSignedTransaction),
+                    type: 'Buffer',
+                },
+            });
+        });
+    }
+    buildAuthTx(message) {
+        const transaction = new web3_js.Transaction();
+        transaction.add(new web3_js.TransactionInstruction({
+            data: Buffer.from(message, 'utf8'),
+            keys: [],
+            programId: MEMO_PROGRAM_ID,
+        }));
+        return transaction;
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        this.verifiedCredentials = verifiedCredentials;
+    }
+    isLedgerAddress(address) {
+        return utils.isLedgerAddressViaVerifiedCredentials(address, this.verifiedCredentials);
+    }
+}
+
+exports.SolWalletConnector = SolWalletConnector;

package/src/solWalletConnector.d.ts

@@ -0,0 +1,37 @@
+import { Connection } from '@solana/web3.js';
+import { IChainRpcProviders } from '@dynamic-labs/rpc-provider-solana';
+import { Chain, IHardwareWalletConnector, WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { GenericNetwork } from '@dynamic-labs/types';
+import { WalletBookSchema } from '@dynamic-labs/wallet-book';
+import { JwtVerifiedCredential } from '@dynamic-labs/sdk-api-core';
+import { ISolana } from './types';
+import { SolanaWallet } from './wallet';
+export type SolWalletConnectorOpts = {
+    chainRpcProviders: IChainRpcProviders;
+    solNetworks: GenericNetwork[];
+    walletBook: WalletBookSchema;
+};
+export declare abstract class SolWalletConnector extends WalletConnectorBase<typeof SolanaWallet> implements IHardwareWalletConnector {
+    isHardwareWalletEnabled: boolean;
+    verifiedCredentials: JwtVerifiedCredential[];
+    solNetworks: GenericNetwork[];
+    ChainWallet: typeof SolanaWallet;
+    supportedChains: Chain[];
+    connectedChain: Chain;
+    constructor(opts: SolWalletConnectorOpts);
+    getNetwork(): Promise<string>;
+    endSession(): Promise<void>;
+    getWalletClient(): Connection;
+    getPublicClient(): Promise<Connection | undefined>;
+    abstract getSigner(): Promise<ISolana | undefined>;
+    abstract connect(): Promise<void>;
+    getBalance(address: string): Promise<string | undefined>;
+    lamportsToSol(lamports: number): number;
+    canConnectWithHardwareWallet(): boolean;
+    signMessage(messageToSign: string): Promise<string | undefined>;
+    proveOwnership(messageToSign: string): Promise<string | undefined>;
+    signMessageViaTransaction(messageToSign: string): Promise<string>;
+    private buildAuthTx;
+    setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    isLedgerAddress(address: string): boolean;
+}