@llayer-network/wallet-standard-wallet-adapter-base 1.1.4

package/src/adapter.ts

@@ -0,0 +1,479 @@
+import {
+    BaseWalletAdapter,
+    isVersionedTransaction,
+    type SendTransactionOptions,
+    type StandardWalletAdapter as StandardWalletAdapterType,
+    type SupportedTransactionVersions,
+    WalletAccountError,
+    type WalletAdapterCompatibleStandardWallet,
+    WalletConfigError,
+    WalletConnectionError,
+    WalletDisconnectedError,
+    WalletDisconnectionError,
+    WalletError,
+    type WalletName,
+    WalletNotConnectedError,
+    WalletNotReadyError,
+    WalletPublicKeyError,
+    WalletReadyState,
+    WalletSendTransactionError,
+    WalletSignInError,
+    WalletSignMessageError,
+    WalletSignTransactionError,
+} from '@solana/wallet-adapter-base';
+import {
+    SolanaSignAndSendTransaction,
+    type SolanaSignAndSendTransactionFeature,
+    SolanaSignIn,
+    type SolanaSignInInput,
+    type SolanaSignInOutput,
+    SolanaSignMessage,
+    SolanaSignTransaction,
+    type SolanaSignTransactionFeature,
+} from '@llayer-network/wallet-standard-features';
+import { getChainForEndpoint, getCommitment } from '@llayer-network/wallet-standard-util';
+import type { Connection, TransactionSignature } from '@solana/web3.js';
+import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import type { WalletAccount } from '@llayer-wallet-standard/base';
+import {
+    StandardConnect,
+    type StandardConnectInput,
+    StandardDisconnect,
+    StandardEvents,
+    type StandardEventsListeners,
+} from '@llayer-wallet-standard/features';
+import { arraysEqual } from '@llayer-wallet-standard/wallet';
+import bs58 from 'bs58';
+
+/** TODO: docs */
+export interface StandardWalletAdapterConfig {
+    wallet: WalletAdapterCompatibleStandardWallet;
+}
+
+/** TODO: docs */
+export class StandardWalletAdapter extends BaseWalletAdapter implements StandardWalletAdapterType {
+    #account: WalletAccount | null;
+    #publicKey: PublicKey | null;
+    #connecting: boolean;
+    #disconnecting: boolean;
+    #off: (() => void) | null;
+    #supportedTransactionVersions: SupportedTransactionVersions;
+    readonly #wallet: WalletAdapterCompatibleStandardWallet;
+    readonly #readyState: WalletReadyState =
+        typeof window === 'undefined' || typeof document === 'undefined'
+            ? WalletReadyState.Unsupported
+            : WalletReadyState.Installed;
+
+    get name() {
+        return this.#wallet.name as WalletName;
+    }
+
+    get url() {
+        return 'https://github.com/solana-labs/wallet-standard';
+    }
+
+    get icon() {
+        return this.#wallet.icon;
+    }
+
+    get readyState() {
+        return this.#readyState;
+    }
+
+    get publicKey() {
+        return this.#publicKey;
+    }
+
+    get connecting() {
+        return this.#connecting;
+    }
+
+    get supportedTransactionVersions() {
+        return this.#supportedTransactionVersions;
+    }
+
+    get wallet(): WalletAdapterCompatibleStandardWallet {
+        return this.#wallet;
+    }
+
+    get standard() {
+        return true as const;
+    }
+
+    constructor({ wallet }: StandardWalletAdapterConfig) {
+        super();
+
+        this.#wallet = wallet;
+        this.#account = null;
+        this.#publicKey = null;
+        this.#connecting = false;
+        this.#disconnecting = false;
+        this.#off = this.#wallet.features[StandardEvents].on('change', this.#changed);
+
+        this.#reset();
+    }
+
+    destroy(): void {
+        this.#account = null;
+        this.#publicKey = null;
+        this.#connecting = false;
+        this.#disconnecting = false;
+
+        const off = this.#off;
+        if (off) {
+            this.#off = null;
+            off();
+        }
+    }
+
+    async autoConnect(): Promise<void> {
+        return this.#connect({ silent: true });
+    }
+
+    async connect(): Promise<void> {
+        return this.#connect();
+    }
+
+    async #connect(input?: StandardConnectInput): Promise<void> {
+        try {
+            if (this.connected || this.connecting) return;
+            if (this.#readyState !== WalletReadyState.Installed) throw new WalletNotReadyError();
+
+            this.#connecting = true;
+
+            if (!this.#wallet.accounts.length) {
+                try {
+                    await this.#wallet.features[StandardConnect].connect(input);
+                } catch (error: any) {
+                    throw new WalletConnectionError(error?.message, error);
+                }
+            }
+
+            const account = this.#wallet.accounts[0];
+            if (!account) throw new WalletAccountError();
+
+            this.#connected(account);
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        } finally {
+            this.#connecting = false;
+        }
+    }
+
+    async disconnect(): Promise<void> {
+        if (StandardDisconnect in this.#wallet.features) {
+            try {
+                this.#disconnecting = true;
+                await this.#wallet.features[StandardDisconnect].disconnect();
+            } catch (error: any) {
+                this.emit('error', new WalletDisconnectionError(error?.message, error));
+            } finally {
+                this.#disconnecting = false;
+            }
+        }
+
+        this.#disconnected();
+    }
+
+    #connected(account: WalletAccount) {
+        let publicKey: PublicKey;
+        try {
+            // Use account.address instead of account.publicKey since address could be a PDA
+            publicKey = new PublicKey(account.address);
+        } catch (error: any) {
+            throw new WalletPublicKeyError(error?.message, error);
+        }
+
+        this.#account = account;
+        this.#publicKey = publicKey;
+        this.#reset();
+        this.emit('connect', publicKey);
+    }
+
+    #disconnected(): void {
+        this.#account = null;
+        this.#publicKey = null;
+        this.#reset();
+        this.emit('disconnect');
+    }
+
+    #reset() {
+        const supportedTransactionVersions =
+            SolanaSignAndSendTransaction in this.#wallet.features
+                ? this.#wallet.features[SolanaSignAndSendTransaction].supportedTransactionVersions
+                : this.#wallet.features[SolanaSignTransaction].supportedTransactionVersions;
+        this.#supportedTransactionVersions = arraysEqual(supportedTransactionVersions, ['legacy'])
+            ? null
+            : new Set(supportedTransactionVersions);
+
+        if (SolanaSignTransaction in this.#wallet.features && this.#account?.features.includes(SolanaSignTransaction)) {
+            this.signTransaction = this.#signTransaction;
+            this.signAllTransactions = this.#signAllTransactions;
+        } else {
+            delete this.signTransaction;
+            delete this.signAllTransactions;
+        }
+
+        if (SolanaSignMessage in this.#wallet.features && this.#account?.features.includes(SolanaSignMessage)) {
+            this.signMessage = this.#signMessage;
+        } else {
+            delete this.signMessage;
+        }
+
+        if (SolanaSignIn in this.#wallet.features) {
+            this.signIn = this.#signIn;
+        } else {
+            delete this.signIn;
+        }
+    }
+
+    #changed: StandardEventsListeners['change'] = (properties) => {
+        // If accounts have changed on the wallet, reflect this on the adapter.
+        if ('accounts' in properties) {
+            const account = this.#wallet.accounts[0];
+            // If the adapter isn't connected, or is disconnecting, or the first account hasn't changed, do nothing.
+            if (this.#account && !this.#disconnecting && account !== this.#account) {
+                // If there's a connected account, connect the adapter. Otherwise, disconnect it.
+                if (account) {
+                    // Connect the adapter.
+                    this.#connected(account);
+                } else {
+                    // Emit an error because the wallet spontaneously disconnected.
+                    this.emit('error', new WalletDisconnectedError());
+                    // Disconnect the adapter.
+                    this.#disconnected();
+                }
+            }
+        }
+
+        // After reflecting account changes, if features have changed on the wallet, reflect this on the adapter.
+        if ('features' in properties) {
+            this.#reset();
+        }
+    };
+
+    async sendTransaction<T extends Transaction | VersionedTransaction>(
+        transaction: T,
+        connection: Connection,
+        options: SendTransactionOptions = {}
+    ): Promise<TransactionSignature> {
+        try {
+            const account = this.#account;
+            if (!account) throw new WalletNotConnectedError();
+
+            let feature: typeof SolanaSignAndSendTransaction | typeof SolanaSignTransaction;
+            if (SolanaSignAndSendTransaction in this.#wallet.features) {
+                if (account.features.includes(SolanaSignAndSendTransaction)) {
+                    feature = SolanaSignAndSendTransaction;
+                } else if (
+                    SolanaSignTransaction in this.#wallet.features &&
+                    account.features.includes(SolanaSignTransaction)
+                ) {
+                    feature = SolanaSignTransaction;
+                } else {
+                    throw new WalletAccountError();
+                }
+            } else if (SolanaSignTransaction in this.#wallet.features) {
+                if (!account.features.includes(SolanaSignTransaction)) throw new WalletAccountError();
+                feature = SolanaSignTransaction;
+            } else {
+                throw new WalletConfigError();
+            }
+
+            const chain = getChainForEndpoint(connection.rpcEndpoint);
+            if (!account.chains.includes(chain)) throw new WalletSendTransactionError();
+
+            try {
+                const { signers, ...sendOptions } = options;
+
+                let serializedTransaction: Uint8Array;
+                if (isVersionedTransaction(transaction)) {
+                    signers?.length && transaction.sign(signers);
+                    serializedTransaction = transaction.serialize();
+                } else {
+                    transaction = (await this.prepareTransaction(transaction, connection, sendOptions)) as T;
+                    signers?.length && (transaction as Transaction).partialSign(...signers);
+                    serializedTransaction = new Uint8Array(
+                        (transaction as Transaction).serialize({
+                            requireAllSignatures: false,
+                            verifySignatures: false,
+                        })
+                    );
+                }
+
+                if (feature === SolanaSignAndSendTransaction) {
+                    const [output] = await (this.#wallet.features as SolanaSignAndSendTransactionFeature)[
+                        SolanaSignAndSendTransaction
+                    ].signAndSendTransaction({
+                        account,
+                        chain,
+                        transaction: serializedTransaction,
+                        options: {
+                            preflightCommitment: getCommitment(
+                                sendOptions.preflightCommitment || connection.commitment
+                            ),
+                            skipPreflight: sendOptions.skipPreflight,
+                            maxRetries: sendOptions.maxRetries,
+                            minContextSlot: sendOptions.minContextSlot,
+                        },
+                    });
+
+                    return bs58.encode(output!.signature);
+                } else {
+                    const [output] = await (this.#wallet.features as SolanaSignTransactionFeature)[
+                        SolanaSignTransaction
+                    ].signTransaction({
+                        account,
+                        chain,
+                        transaction: serializedTransaction,
+                        options: {
+                            preflightCommitment: getCommitment(
+                                sendOptions.preflightCommitment || connection.commitment
+                            ),
+                            minContextSlot: sendOptions.minContextSlot,
+                        },
+                    });
+
+                    return await connection.sendRawTransaction(output!.signedTransaction, {
+                        ...sendOptions,
+                        preflightCommitment: getCommitment(sendOptions.preflightCommitment || connection.commitment),
+                    });
+                }
+            } catch (error: any) {
+                if (error instanceof WalletError) throw error;
+                throw new WalletSendTransactionError(error?.message, error);
+            }
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    signTransaction: (<T extends Transaction | VersionedTransaction>(transaction: T) => Promise<T>) | undefined;
+    async #signTransaction<T extends Transaction | VersionedTransaction>(transaction: T): Promise<T> {
+        try {
+            const account = this.#account;
+            if (!account) throw new WalletNotConnectedError();
+
+            if (!(SolanaSignTransaction in this.#wallet.features)) throw new WalletConfigError();
+            if (!account.features.includes(SolanaSignTransaction)) throw new WalletAccountError();
+
+            try {
+                const signedTransactions = await this.#wallet.features[SolanaSignTransaction].signTransaction({
+                    account,
+                    transaction: isVersionedTransaction(transaction)
+                        ? transaction.serialize()
+                        : new Uint8Array(
+                              transaction.serialize({
+                                  requireAllSignatures: false,
+                                  verifySignatures: false,
+                              })
+                          ),
+                });
+
+                const serializedTransaction = signedTransactions[0]!.signedTransaction;
+
+                return (
+                    isVersionedTransaction(transaction)
+                        ? VersionedTransaction.deserialize(serializedTransaction)
+                        : Transaction.from(serializedTransaction)
+                ) as T;
+            } catch (error: any) {
+                if (error instanceof WalletError) throw error;
+                throw new WalletSignTransactionError(error?.message, error);
+            }
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    signAllTransactions: (<T extends Transaction | VersionedTransaction>(transaction: T[]) => Promise<T[]>) | undefined;
+    async #signAllTransactions<T extends Transaction | VersionedTransaction>(transactions: T[]): Promise<T[]> {
+        try {
+            const account = this.#account;
+            if (!account) throw new WalletNotConnectedError();
+
+            if (!(SolanaSignTransaction in this.#wallet.features)) throw new WalletConfigError();
+            if (!account.features.includes(SolanaSignTransaction)) throw new WalletAccountError();
+
+            try {
+                const signedTransactions = await this.#wallet.features[SolanaSignTransaction].signTransaction(
+                    ...transactions.map((transaction) => ({
+                        account,
+                        transaction: isVersionedTransaction(transaction)
+                            ? transaction.serialize()
+                            : new Uint8Array(
+                                  transaction.serialize({
+                                      requireAllSignatures: false,
+                                      verifySignatures: false,
+                                  })
+                              ),
+                    }))
+                );
+
+                return transactions.map((transaction, index) => {
+                    const signedTransaction = signedTransactions[index]!.signedTransaction;
+
+                    return (
+                        isVersionedTransaction(transaction)
+                            ? VersionedTransaction.deserialize(signedTransaction)
+                            : Transaction.from(signedTransaction)
+                    ) as T;
+                });
+            } catch (error: any) {
+                throw new WalletSignTransactionError(error?.message, error);
+            }
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    signMessage: ((message: Uint8Array) => Promise<Uint8Array>) | undefined;
+    async #signMessage(message: Uint8Array): Promise<Uint8Array> {
+        try {
+            const account = this.#account;
+            if (!account) throw new WalletNotConnectedError();
+
+            if (!(SolanaSignMessage in this.#wallet.features)) throw new WalletConfigError();
+            if (!account.features.includes(SolanaSignMessage)) throw new WalletAccountError();
+
+            try {
+                const signedMessages = await this.#wallet.features[SolanaSignMessage].signMessage({
+                    account,
+                    message,
+                });
+
+                return signedMessages[0]!.signature;
+            } catch (error: any) {
+                throw new WalletSignMessageError(error?.message, error);
+            }
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+
+    signIn: ((input?: SolanaSignInInput) => Promise<SolanaSignInOutput>) | undefined;
+    async #signIn(input: SolanaSignInInput = {}): Promise<SolanaSignInOutput> {
+        try {
+            if (!(SolanaSignIn in this.#wallet.features)) throw new WalletConfigError();
+
+            let output: SolanaSignInOutput | undefined;
+            try {
+                [output] = await this.#wallet.features[SolanaSignIn].signIn(input);
+            } catch (error: any) {
+                throw new WalletSignInError(error?.message, error);
+            }
+
+            if (!output) throw new WalletSignInError();
+            this.#connected(output.account);
+            return output;
+        } catch (error: any) {
+            this.emit('error', error);
+            throw error;
+        }
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './adapter.js';
+export * from './types.js';
+export * from './wallet.js';

package/src/types.ts

@@ -0,0 +1,26 @@
+import {
+    isWalletAdapterCompatibleStandardWallet,
+    type StandardWalletAdapter,
+    type WalletAdapterCompatibleStandardWallet,
+} from '@solana/wallet-adapter-base';
+
+/**
+ * @deprecated Use `StandardWalletAdapter` from `@solana/wallet-adapter-base` instead.
+ *
+ * @group Deprecated
+ */
+export type StandardAdapter = StandardWalletAdapter;
+
+/**
+ * @deprecated Use `WalletAdapterCompatibleStandardWallet` from `@solana/wallet-adapter-base` instead.
+ *
+ * @group Deprecated
+ */
+export type WalletAdapterCompatibleWallet = WalletAdapterCompatibleStandardWallet;
+
+/**
+ * @deprecated Use `isWalletAdapterCompatibleStandardWallet` from `@solana/wallet-adapter-base` instead.
+ *
+ * @group Deprecated
+ */
+export const isWalletAdapterCompatibleWallet = isWalletAdapterCompatibleStandardWallet;