@dynamic-labs/solana-core 3.0.0-alpha.52 → 3.0.0-alpha.54

package/CHANGELOG.md

@@ -1,4 +1,50 @@
 
+## [3.0.0-alpha.54](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.53...v3.0.0-alpha.54) (2024-08-29)
+
+
+### Bug Fixes
+
+* transaction hanging in confirmation modal ([#6740](https://github.com/dynamic-labs/DynamicAuth/issues/6740)) ([f03d286](https://github.com/dynamic-labs/DynamicAuth/commit/f03d286aaf471dbc7a6149acee10512be7b56b18))
+
+## [3.0.0-alpha.53](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.52...v3.0.0-alpha.53) (2024-08-29)
+
+
+### ⚠ BREAKING CHANGES
+
+* simplify solana wallet signer types (#6748)
+* deprecate getEoaConnector (#6571)
+* limit methods and props returned by wallet.connector (#6540)
+* move generic solana code to solana-core package (#6701)
+* revamp ether v6 interface (#6548)
+* add ethereum wallet specific methods and intercept to sync when needed (#6662)
+* add solana wallet specific methods and intercept to sync when needed (#6608)
+* don't force primary wallet to be connected (#6128)
+
+### Features
+
+* add bitcoin wallet specific methods and intercept to sync when needed ([#6663](https://github.com/dynamic-labs/DynamicAuth/issues/6663)) ([ed699b1](https://github.com/dynamic-labs/DynamicAuth/commit/ed699b1f8c264755779ec4840d105f89ade5500e))
+* add ethereum wallet specific methods and intercept to sync when needed ([#6662](https://github.com/dynamic-labs/DynamicAuth/issues/6662)) ([372360e](https://github.com/dynamic-labs/DynamicAuth/commit/372360ed7ca395f88811fc62c94b2b494eb59971))
+* add solana wallet specific methods and intercept to sync when needed ([#6608](https://github.com/dynamic-labs/DynamicAuth/issues/6608)) ([565f610](https://github.com/dynamic-labs/DynamicAuth/commit/565f6100340296c267e9706fd263e9bd3f7d3732))
+* add useSmartWallets hook to manage aa wallets ([#6564](https://github.com/dynamic-labs/DynamicAuth/issues/6564)) ([a243d36](https://github.com/dynamic-labs/DynamicAuth/commit/a243d361ce7c368d0f1afda55f9c1fabefd75ba8))
+* don't force primary wallet to be connected ([#6128](https://github.com/dynamic-labs/DynamicAuth/issues/6128)) ([018a6f6](https://github.com/dynamic-labs/DynamicAuth/commit/018a6f66f8725914ab97ea3e2e1c80626266e503))
+* new prop to enable prompt for linking when account change is detected ([#6713](https://github.com/dynamic-labs/DynamicAuth/issues/6713)) ([b5a6321](https://github.com/dynamic-labs/DynamicAuth/commit/b5a63212ae33fae24401f141d5ca2356b446dcff))
+
+
+### Bug Fixes
+
+* always sync wagmi client with primary wallet ([#6577](https://github.com/dynamic-labs/DynamicAuth/issues/6577)) ([be22fde](https://github.com/dynamic-labs/DynamicAuth/commit/be22fdea3bb61db79b06ba56cb32da6cd8141b66))
+* cosmos wallet intercepts ([#6720](https://github.com/dynamic-labs/DynamicAuth/issues/6720)) ([cfc9df4](https://github.com/dynamic-labs/DynamicAuth/commit/cfc9df48a8032f7348fec14f77b9e378d2e26a22))
+* magiceden wallet events not working correctly on page refresh ([#6735](https://github.com/dynamic-labs/DynamicAuth/issues/6735)) ([6ed5964](https://github.com/dynamic-labs/DynamicAuth/commit/6ed5964134a2cafd392c19f18eb71e6ca2ce238d))
+* use proxy to intercept solana signer methods ([#6743](https://github.com/dynamic-labs/DynamicAuth/issues/6743)) ([ecbe5ea](https://github.com/dynamic-labs/DynamicAuth/commit/ecbe5ea772592d2c693d8222d85b7642acd151a8))
+* wallet.chain references ([525c1ca](https://github.com/dynamic-labs/DynamicAuth/commit/525c1ca9a8fe6402c06eabe6aebc30e310411d9b))
+
+
+* deprecate getEoaConnector ([#6571](https://github.com/dynamic-labs/DynamicAuth/issues/6571)) ([0226ee5](https://github.com/dynamic-labs/DynamicAuth/commit/0226ee5a13f2418607076ee6f2ec0a579b06dd5d))
+* limit methods and props returned by wallet.connector ([#6540](https://github.com/dynamic-labs/DynamicAuth/issues/6540)) ([9c86e35](https://github.com/dynamic-labs/DynamicAuth/commit/9c86e35c72cd40313bfd19254dd6171ee8f62213))
+* move generic solana code to solana-core package ([#6701](https://github.com/dynamic-labs/DynamicAuth/issues/6701)) ([30815f5](https://github.com/dynamic-labs/DynamicAuth/commit/30815f5d46feeefb2413c1b7d30b43d5370ee032))
+* revamp ether v6 interface ([#6548](https://github.com/dynamic-labs/DynamicAuth/issues/6548)) ([f3b2fb8](https://github.com/dynamic-labs/DynamicAuth/commit/f3b2fb8da7de21f9c58e67fa7f5580166195092a))
+* simplify solana wallet signer types ([#6748](https://github.com/dynamic-labs/DynamicAuth/issues/6748)) ([01d1a42](https://github.com/dynamic-labs/DynamicAuth/commit/01d1a42bc916ab329580b741ba60d706bf6c5491))
+
 ## [3.0.0-alpha.52](https://github.com/dynamic-labs/DynamicAuth/compare/v3.0.0-alpha.51...v3.0.0-alpha.52) (2024-08-28)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dynamic-labs/solana-core",
-  "version": "3.0.0-alpha.52",
+  "version": "3.0.0-alpha.54",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/dynamic-labs/dynamic-auth.git",
@@ -26,13 +26,16 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
+    "@dynamic-labs/sdk-api-core": "0.0.519",
     "@solana/web3.js": "1.92.1",
     "@solana/spl-token": "0.4.6"
   },
   "peerDependencies": {
-    "@dynamic-labs/rpc-providers": "3.0.0-alpha.52",
-    "@dynamic-labs/sdk-api-core": "0.0.519",
-    "@dynamic-labs/types": "3.0.0-alpha.52",
-    "@dynamic-labs/utils": "3.0.0-alpha.52"
+    "@dynamic-labs/rpc-providers": "3.0.0-alpha.54",
+    "@dynamic-labs/types": "3.0.0-alpha.54",
+    "@dynamic-labs/utils": "3.0.0-alpha.54",
+    "@dynamic-labs/wallet-book": "3.0.0-alpha.54",
+    "@dynamic-labs/wallet-connector-core": "3.0.0-alpha.54",
+    "eventemitter3": "5.0.1"
   }
 }

package/src/connector/SolWalletConnector.cjs

@@ -0,0 +1,175 @@
+'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 SolanaWallet = require('../wallet/SolanaWallet.cjs');
+var extractNonce = require('../utils/extractNonce/extractNonce.cjs');
+var getGenesisHashLSKey = require('../utils/getGenesisHashLSKey/getGenesisHashLSKey.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(address, messageToSign) {
+        const _super = Object.create(null, {
+            proveOwnership: { get: () => super.proveOwnership }
+        });
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(address);
+            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, address, 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/connector/SolWalletConnector.d.ts

@@ -0,0 +1,37 @@
+import { Connection } from '@solana/web3.js';
+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 { IChainRpcProviders } from '../rpc';
+import { SolanaWallet } from '../wallet';
+import { ISolana } from '../types';
+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(address: string, messageToSign: string): Promise<string | undefined>;
+    signMessageViaTransaction(messageToSign: string): Promise<string>;
+    private buildAuthTx;
+    setVerifiedCredentials(verifiedCredentials: JwtVerifiedCredential[]): void;
+    isLedgerAddress(address: string): boolean;
+}

package/src/connector/SolWalletConnector.js

@@ -0,0 +1,171 @@
+'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, isLedgerAddressViaVerifiedCredentials, NotSupportedError } from '@dynamic-labs/utils';
+import { findWalletBookWallet } from '@dynamic-labs/wallet-book';
+import { SolanaWallet } from '../wallet/SolanaWallet.js';
+import { extractNonce } from '../utils/extractNonce/extractNonce.js';
+import { getGenesisHashLSKey } from '../utils/getGenesisHashLSKey/getGenesisHashLSKey.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(address, messageToSign) {
+        const _super = Object.create(null, {
+            proveOwnership: { get: () => super.proveOwnership }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.validateActiveWallet(address);
+            if (this.isHardwareWalletEnabled) {
+                const nonce = extractNonce(messageToSign);
+                if (!nonce) {
+                    throw new DynamicError('Nonce missing');
+                }
+                return this.signMessageViaTransaction(nonce);
+            }
+            return _super.proveOwnership.call(this, address, 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/connector/index.d.ts

@@ -0,0 +1 @@
+export * from './SolWalletConnector';

package/src/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/constants.d.ts

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

package/src/constants.js

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

package/src/index.cjs

@@ -3,6 +3,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var SolWalletConnector = require('./connector/SolWalletConnector.cjs');
 require('./rpc/RpcProviderSolana/RpcProviderSolana.cjs');
 var rpcProviders = require('@dynamic-labs/rpc-providers');
 var solanaProvidersSelector = require('./rpc/solanaProvidersSelector/solanaProvidersSelector.cjs');
@@ -10,17 +11,26 @@ var SolanaUiTransaction = require('./utils/SolanaUiTransaction/SolanaUiTransacti
 var decodeTransactionFromBase64 = require('./utils/decodeTransactionFromBase64/decodeTransactionFromBase64.cjs');
 var isVersionedTransaction = require('./utils/isVersionedTransaction/isVersionedTransaction.cjs');
 var encodeTransactionToBase64 = require('./utils/encodeTransactionToBase64/encodeTransactionToBase64.cjs');
+var getGenesisHashLSKey = require('./utils/getGenesisHashLSKey/getGenesisHashLSKey.cjs');
+var SolanaWallet = require('./wallet/SolanaWallet.cjs');
+var isSolanaWallet = require('./wallet/isSolanaWallet/isSolanaWallet.cjs');
+var constants = require('./constants.cjs');
 
 
 
+exports.SolWalletConnector = SolWalletConnector.SolWalletConnector;
 exports.solanaProvidersSelector = solanaProvidersSelector.solanaProvidersSelector;
 exports.SolanaUiTransaction = SolanaUiTransaction.SolanaUiTransaction;
 exports.decodeTransactionFromBase64 = decodeTransactionFromBase64.decodeTransactionFromBase64;
 exports.isVersionedTransaction = isVersionedTransaction.isVersionedTransaction;
 exports.encodeTransactionToBase64 = encodeTransactionToBase64.encodeTransactionToBase64;
+exports.getGenesisHashLSKey = getGenesisHashLSKey.getGenesisHashLSKey;
+exports.SolanaWallet = SolanaWallet.SolanaWallet;
+exports.isSolanaWallet = isSolanaWallet.isSolanaWallet;
+exports.SOLANA_GENESIS_HASH = constants.SOLANA_GENESIS_HASH;
 Object.keys(rpcProviders).forEach(function (k) {
-	if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return rpcProviders[k]; }
-	});
+  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return rpcProviders[k]; }
+  });
 });

package/src/index.d.ts

@@ -1,2 +1,6 @@
+export * from './connector';
 export * from './rpc';
 export * from './utils';
+export * from './wallet';
+export { SOLANA_GENESIS_HASH } from './constants';
+export type { ConnectionResult, ExtensionLocator, ISolana, IBackpackSolanaSigner, SignedMessage, ISolanaSigner, } from './types';

package/src/index.js

@@ -1,4 +1,5 @@
 'use client'
+export { SolWalletConnector } from './connector/SolWalletConnector.js';
 import './rpc/RpcProviderSolana/RpcProviderSolana.js';
 export * from '@dynamic-labs/rpc-providers';
 export { solanaProvidersSelector } from './rpc/solanaProvidersSelector/solanaProvidersSelector.js';
@@ -6,3 +7,7 @@ export { SolanaUiTransaction } from './utils/SolanaUiTransaction/SolanaUiTransac
 export { decodeTransactionFromBase64 } from './utils/decodeTransactionFromBase64/decodeTransactionFromBase64.js';
 export { isVersionedTransaction } from './utils/isVersionedTransaction/isVersionedTransaction.js';
 export { encodeTransactionToBase64 } from './utils/encodeTransactionToBase64/encodeTransactionToBase64.js';
+export { getGenesisHashLSKey } from './utils/getGenesisHashLSKey/getGenesisHashLSKey.js';
+export { SolanaWallet } from './wallet/SolanaWallet.js';
+export { isSolanaWallet } from './wallet/isSolanaWallet/isSolanaWallet.js';
+export { SOLANA_GENESIS_HASH } from './constants.js';

package/src/types.d.ts

@@ -0,0 +1,60 @@
+import { Connection, SendOptions, Signer, Transaction, TransactionSignature, VersionedTransaction } from '@solana/web3.js';
+import EventEmitter from 'eventemitter3';
+declare global {
+    interface IWindowPhantom {
+        solana: ISolana;
+    }
+    interface Window {
+        coinbaseSolana?: ISolana;
+        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;
+};
+type ExtensionLocators = {
+    [key in ExtensionLocator]: boolean;
+};
+export type ISolanaSigner = ExtensionLocators & 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>;
+};
+export type IBackpackSolanaSigner = ISolanaSigner & {
+    send: (transaction: Transaction, signers?: Signer[], options?: SendOptions, connection?: Connection, publicKey?: PublicKey) => Promise<TransactionSignature>;
+};
+export type ISolana = ISolanaSigner | IBackpackSolanaSigner;
+export type ExtensionLocator = 'isBraveWallet' | 'isGlow' | 'isPhantom' | 'isSolflare' | 'isExodus' | 'isBackpack' | 'isMagicEden';
+export {};

package/src/utils/extractNonce/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/extractNonce.d.ts

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

package/src/utils/extractNonce/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/extractNonce/index.d.ts

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

package/src/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/utils/getGenesisHashLSKey/getGenesisHashLSKey.d.ts

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

package/src/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/utils/getGenesisHashLSKey/index.d.ts

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

package/src/utils/index.d.ts

@@ -2,3 +2,4 @@ export { SolanaUiTransaction } from './SolanaUiTransaction';
 export { decodeTransactionFromBase64 } from './decodeTransactionFromBase64';
 export { isVersionedTransaction } from './isVersionedTransaction';
 export { encodeTransactionToBase64, type EncodedTransaction, } from './encodeTransactionToBase64';
+export { getGenesisHashLSKey } from './getGenesisHashLSKey';

package/src/wallet/SolanaWallet.cjs

@@ -0,0 +1,68 @@
+'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
+     */
+    getConnection() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            return this._connector.getWalletClient();
+        });
+    }
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or throws an error if the signer cannot be retrieved.
+     */
+    getSigner() {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const signer = yield this._connector.getSigner();
+            if (!signer) {
+                throw new Error('unable to retrieve Solana signer');
+            }
+            const proxiedSigner = new Proxy(signer, {
+                get: (target, prop) => {
+                    switch (prop) {
+                        case 'signTransaction': {
+                            return (transaction) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signTransaction(transaction);
+                            });
+                        }
+                        case 'signAllTransactions': {
+                            return (transactions) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signAllTransactions(transactions);
+                            });
+                        }
+                        case 'signAndSendTransaction': {
+                            return (transaction, ...args) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signAndSendTransaction(transaction, ...args);
+                            });
+                        }
+                        case 'signMessage': {
+                            return (message, ...args) => _tslib.__awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signMessage(message, ...args);
+                            });
+                        }
+                        default: {
+                            return Reflect.get(target, prop);
+                        }
+                    }
+                },
+            });
+            return proxiedSigner;
+        });
+    }
+}
+
+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 '../connector';
+import { ISolana } from '../types';
+export declare class SolanaWallet extends Wallet<SolWalletConnector> {
+    /**
+     * Retrieves the RPC connection
+     * @returns A promise that resolves to the RPC connection
+     */
+    getConnection(): Promise<Connection>;
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or throws an error if the signer cannot be retrieved.
+     */
+    getSigner(): Promise<ISolana>;
+}

package/src/wallet/SolanaWallet.js

@@ -0,0 +1,64 @@
+'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
+     */
+    getConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this._connector.getWalletClient();
+        });
+    }
+    /**
+     * Retrieves the solana signer for the wallet.
+     * @returns A promise that resolves to the signer,
+     * or throws an error if the signer cannot be retrieved.
+     */
+    getSigner() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = yield this._connector.getSigner();
+            if (!signer) {
+                throw new Error('unable to retrieve Solana signer');
+            }
+            const proxiedSigner = new Proxy(signer, {
+                get: (target, prop) => {
+                    switch (prop) {
+                        case 'signTransaction': {
+                            return (transaction) => __awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signTransaction(transaction);
+                            });
+                        }
+                        case 'signAllTransactions': {
+                            return (transactions) => __awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signAllTransactions(transactions);
+                            });
+                        }
+                        case 'signAndSendTransaction': {
+                            return (transaction, ...args) => __awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signAndSendTransaction(transaction, ...args);
+                            });
+                        }
+                        case 'signMessage': {
+                            return (message, ...args) => __awaiter(this, void 0, void 0, function* () {
+                                yield this.sync();
+                                return target.signMessage(message, ...args);
+                            });
+                        }
+                        default: {
+                            return Reflect.get(target, prop);
+                        }
+                    }
+                },
+            });
+            return proxiedSigner;
+        });
+    }
+}
+
+export { SolanaWallet };

package/src/wallet/index.d.ts

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

package/src/wallet/isSolanaWallet/index.d.ts

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

package/src/wallet/isSolanaWallet/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/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/isSolanaWallet.js

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