@dynamic-labs/solana 0.0.0-exp20240808.0

package/src/solWalletConnector.js

@@ -0,0 +1,170 @@
+'use client'
+import { __awaiter } from '../_virtual/_tslib.js';
+import { PublicKey, Connection, Transaction, TransactionInstruction } from '@solana/web3.js';
+import { WalletConnectorBase } from '@dynamic-labs/wallet-connector-core';
+import { DynamicError, NotSupportedError, isLedgerAddressViaVerifiedCredentials } from '@dynamic-labs/utils';
+import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import { extractNonce } from './utils/extractNonce.js';
+import { getGenesisHashLSKey } from './utils/getGenesisHashLSKey.js';
+import { SolanaWallet } from './wallet/SolanaWallet.js';
+
+const MEMO_PROGRAM_ID = new PublicKey('MemoSq4gqABAXKb96qnH8TysNcWxMyWCqXgDLGmfcHr');
+class SolWalletConnector extends WalletConnectorBase {
+    constructor(opts) {
+        var _a;
+        super(opts);
+        this.isHardwareWalletEnabled = false;
+        this.verifiedCredentials = [];
+        this.ChainWallet = 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 __awaiter(this, void 0, void 0, function* () {
+            const provider = this.getWalletClient();
+            let genesisHash = localStorage.getItem(getGenesisHashLSKey(provider.rpcEndpoint));
+            if (!genesisHash) {
+                genesisHash = yield provider.getGenesisHash();
+                localStorage.setItem(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 __awaiter(this, void 0, void 0, function* () {
+            localStorage.removeItem(getGenesisHashLSKey(this.getWalletClient().rpcEndpoint));
+        });
+    }
+    getWalletClient() {
+        var _a;
+        const [network] = this.solNetworks;
+        if (!network) {
+            throw new DynamicError('No enabled networks');
+        }
+        const rpcUrl = ((_a = network.privateCustomerRpcUrls) === null || _a === void 0 ? void 0 : _a[0]) || network.rpcUrls[0];
+        return new Connection(rpcUrl, 'confirmed');
+    }
+    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;
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publicKey = new 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 = 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 __awaiter(this, void 0, void 0, function* () {
+            if (this.isHardwareWalletEnabled) {
+                throw new 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 __awaiter(this, void 0, void 0, function* () {
+            if (this.isHardwareWalletEnabled) {
+                const nonce = extractNonce(messageToSign);
+                if (!nonce) {
+                    throw new DynamicError('Nonce missing');
+                }
+                return this.signMessageViaTransaction(nonce);
+            }
+            return _super.proveOwnership.call(this, messageToSign);
+        });
+    }
+    signMessageViaTransaction(messageToSign) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            if (!address) {
+                throw new DynamicError('Address missing');
+            }
+            const transaction = this.buildAuthTx(messageToSign);
+            transaction.feePayer = new PublicKey(address);
+            transaction.recentBlockhash = (yield this.getWalletClient().getLatestBlockhash()).blockhash;
+            const signer = yield this.getSigner();
+            if (!signer) {
+                throw new 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 Transaction();
+        transaction.add(new TransactionInstruction({
+            data: Buffer.from(message, 'utf8'),
+            keys: [],
+            programId: MEMO_PROGRAM_ID,
+        }));
+        return transaction;
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        this.verifiedCredentials = verifiedCredentials;
+    }
+    isLedgerAddress(address) {
+        return isLedgerAddressViaVerifiedCredentials(address, this.verifiedCredentials);
+    }
+}
+
+export { SolWalletConnector };

package/src/types.d.ts

@@ -0,0 +1,68 @@
+import { Connection, SendOptions, Signer, Transaction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import EventEmitter from 'eventemitter3';
+import { ProviderCondition } from '@dynamic-labs/wallet-connector-core';
+declare global {
+    interface IWindowPhantom {
+        solana: ISolana;
+    }
+    interface Window {
+        coinbaseSolana?: ICoinbaseSolanaSigner;
+        glowSolana?: ISolana;
+        phantom?: IWindowPhantom;
+        solana?: ISolana;
+        solflare?: ISolana;
+        backpack?: IBackpackSolanaSigner;
+        magicEden?: {
+            solana: ISolana;
+        };
+    }
+}
+type PublicKey = {
+    toString: () => string;
+};
+export type ConnectionResult = {
+    address?: string;
+    publicKey?: PublicKey;
+} | undefined;
+interface ISolanaEvents {
+    connect(...args: unknown[]): unknown;
+    disconnect(...args: unknown[]): unknown;
+    accountChanged(publicKey: string): unknown;
+    activeWalletDidChange(publicKey: string): unknown;
+}
+export type SignedMessage = {
+    signature: Uint8Array;
+};
+export type ISolanaSigner = {
+    [key in ExtensionLocator]: boolean;
+} & EventEmitter<ISolanaEvents> & {
+    publicKey?: {
+        toBytes(): Uint8Array;
+    };
+    isConnected: boolean;
+    providers: ISolanaSigner[];
+    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;
+    }>;
+    signMessage(message: Uint8Array, encoding?: string): Promise<SignedMessage>;
+    connect: (args?: {
+        onlyIfTrusted: boolean;
+    }) => Promise<ConnectionResult>;
+    disconnect(): Promise<void>;
+};
+type BackpackSolanaSignerResponse = {
+    signature: Uint8Array;
+};
+export type IBackpackSolanaSigner = Omit<ISolanaSigner, 'signMessage'> & {
+    signMessage: (message: Uint8Array, encoding?: string) => Promise<void | BackpackSolanaSignerResponse | Uint8Array>;
+    send: (transaction: Transaction, signers?: Signer[], options?: SendOptions, connection?: Connection, publicKey?: PublicKey) => Promise<TransactionSignature>;
+};
+export type ICoinbaseSolanaSigner = Omit<ISolanaSigner, 'signMessage'> & {
+    signMessage: (message: Uint8Array, publicKey?: string) => Promise<void | Uint8Array>;
+};
+export type ISolana = ISolanaSigner | IBackpackSolanaSigner | ICoinbaseSolanaSigner;
+export type ExtensionLocator = 'isBraveWallet' | 'isGlow' | 'isPhantom' | 'isSolflare' | 'isExodus' | 'isBackpack' | 'isMagicEden';
+export type EthProviderCondition = ProviderCondition<ExtensionLocator>;
+export {};

package/src/utils/extractNonce.cjs

@@ -0,0 +1,14 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const extractNonce = (messageToSign) => {
+    const regex = messageToSign.match(/Nonce: (.*)/);
+    if (regex && regex.length === 2) {
+        return regex[1];
+    }
+    return undefined;
+};
+
+exports.extractNonce = extractNonce;

package/src/utils/extractNonce.d.ts

@@ -0,0 +1 @@
+export declare const extractNonce: (messageToSign: string) => string | undefined;

package/src/utils/extractNonce.js

@@ -0,0 +1,10 @@
+'use client'
+const extractNonce = (messageToSign) => {
+    const regex = messageToSign.match(/Nonce: (.*)/);
+    if (regex && regex.length === 2) {
+        return regex[1];
+    }
+    return undefined;
+};
+
+export { extractNonce };

package/src/utils/findWalletProviderFromWalletStandard/findWalletProviderFromWalletStandard.cjs

@@ -0,0 +1,29 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var app = require('@wallet-standard/app');
+var utils = require('@dynamic-labs/utils');
+
+const findWalletProviderFromWalletStandard = (injectConfig) => {
+    const { walletStandardLocators } = injectConfig;
+    if (!walletStandardLocators || walletStandardLocators.length === 0) {
+        return undefined;
+    }
+    const wallets = app.getWallets().get();
+    return walletStandardLocators.reduce((provider, walletStandardLocator) => {
+        /**
+         * Return early if the provider is already found
+         */
+        if (provider) {
+            return provider;
+        }
+        const wallet = wallets.find((w) => w.name === walletStandardLocator.name);
+        if (!wallet)
+            return undefined;
+        return utils.get(wallet, walletStandardLocator.locator);
+    }, undefined);
+};
+
+exports.findWalletProviderFromWalletStandard = findWalletProviderFromWalletStandard;

package/src/utils/findWalletProviderFromWalletStandard/findWalletProviderFromWalletStandard.d.ts

@@ -0,0 +1,3 @@
+import { WalletSchema } from '@dynamic-labs/wallet-book';
+import { ISolana } from '../../types';
+export declare const findWalletProviderFromWalletStandard: (injectConfig: NonNullable<WalletSchema['injectedConfig']>[number]) => ISolana | undefined;

package/src/utils/findWalletProviderFromWalletStandard/findWalletProviderFromWalletStandard.js

@@ -0,0 +1,25 @@
+'use client'
+import { getWallets } from '@wallet-standard/app';
+import { get } from '@dynamic-labs/utils';
+
+const findWalletProviderFromWalletStandard = (injectConfig) => {
+    const { walletStandardLocators } = injectConfig;
+    if (!walletStandardLocators || walletStandardLocators.length === 0) {
+        return undefined;
+    }
+    const wallets = getWallets().get();
+    return walletStandardLocators.reduce((provider, walletStandardLocator) => {
+        /**
+         * Return early if the provider is already found
+         */
+        if (provider) {
+            return provider;
+        }
+        const wallet = wallets.find((w) => w.name === walletStandardLocator.name);
+        if (!wallet)
+            return undefined;
+        return get(wallet, walletStandardLocator.locator);
+    }, undefined);
+};
+
+export { findWalletProviderFromWalletStandard };

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

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

package/src/utils/getGenesisHashLSKey.cjs

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

package/src/utils/getGenesisHashLSKey.d.ts

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

package/src/utils/getGenesisHashLSKey.js

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

package/src/utils/isBackpackSolanaSigner.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isBackpackSolanaSigner = (signer) => Boolean(signer) && signer.send !== undefined;
+
+exports.isBackpackSolanaSigner = isBackpackSolanaSigner;

package/src/utils/isBackpackSolanaSigner.d.ts

@@ -0,0 +1,2 @@
+import { IBackpackSolanaSigner, ISolana } from '../types';
+export declare const isBackpackSolanaSigner: (signer: ISolana) => signer is IBackpackSolanaSigner;

package/src/utils/isBackpackSolanaSigner.js

@@ -0,0 +1,4 @@
+'use client'
+const isBackpackSolanaSigner = (signer) => Boolean(signer) && signer.send !== undefined;
+
+export { isBackpackSolanaSigner };

package/src/utils/isSignedMessage.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isSignedMessage = (message) => Boolean(message) && message.signature !== undefined;
+
+exports.isSignedMessage = isSignedMessage;

package/src/utils/isSignedMessage.d.ts

@@ -0,0 +1,2 @@
+import { SignedMessage } from '../types';
+export declare const isSignedMessage: (message: SignedMessage | Uint8Array) => message is SignedMessage;

package/src/utils/isSignedMessage.js

@@ -0,0 +1,4 @@
+'use client'
+const isSignedMessage = (message) => Boolean(message) && message.signature !== undefined;
+
+export { isSignedMessage };

package/src/wallet/SolanaWallet.cjs

@@ -0,0 +1,33 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../_virtual/_tslib.cjs');
+var walletConnectorCore = require('@dynamic-labs/wallet-connector-core');
+
+class SolanaWallet extends walletConnectorCore.Wallet {
+    /**
+     * Retrieves the RPC connection
+     * @returns A promise that resolves to the RPC connection
+     */
+    getConnnection() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.getWalletClient();
+        });
+    }
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or undefined if the signer cannot be retrieved.
+     */
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.getSigner();
+        });
+    }
+}
+
+exports.SolanaWallet = SolanaWallet;

package/src/wallet/SolanaWallet.d.ts

@@ -0,0 +1,17 @@
+import { Connection } from '@solana/web3.js';
+import { Wallet } from '@dynamic-labs/wallet-connector-core';
+import { SolWalletConnector } from '../solWalletConnector';
+import { ISolana } from '../types';
+export declare class SolanaWallet extends Wallet<SolWalletConnector> {
+    /**
+     * Retrieves the RPC connection
+     * @returns A promise that resolves to the RPC connection
+     */
+    getConnnection(): Promise<Connection>;
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or undefined if the signer cannot be retrieved.
+     */
+    getSigner(): Promise<ISolana | undefined>;
+}

package/src/wallet/SolanaWallet.js

@@ -0,0 +1,29 @@
+'use client'
+import { __awaiter } from '../../_virtual/_tslib.js';
+import { Wallet } from '@dynamic-labs/wallet-connector-core';
+
+class SolanaWallet extends Wallet {
+    /**
+     * Retrieves the RPC connection
+     * @returns A promise that resolves to the RPC connection
+     */
+    getConnnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.getWalletClient();
+        });
+    }
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or undefined if the signer cannot be retrieved.
+     */
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+            return this._connector.getSigner();
+        });
+    }
+}
+
+export { SolanaWallet };

package/src/wallet/index.d.ts

@@ -0,0 +1,2 @@
+export * from './SolanaWallet';
+export * from './isSolanaWallet';

package/src/wallet/isSolanaWallet.cjs

@@ -0,0 +1,8 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const isSolanaWallet = (wallet) => wallet.chain === 'SOL';
+
+exports.isSolanaWallet = isSolanaWallet;

package/src/wallet/isSolanaWallet.d.ts

@@ -0,0 +1,3 @@
+import { Wallet } from '@dynamic-labs/wallet-connector-core';
+import { SolanaWallet } from './SolanaWallet';
+export declare const isSolanaWallet: (wallet: Wallet) => wallet is SolanaWallet;

package/src/wallet/isSolanaWallet.js

@@ -0,0 +1,4 @@
+'use client'
+const isSolanaWallet = (wallet) => wallet.chain === 'SOL';
+
+export { isSolanaWallet };