@web3auth/no-modal/dist/lib.esm/connectors/wallet-connect-v2-connector/wcSolanaWallet.js

Multi chain wallet aggregator for web3Auth

import _objectSpread from '@babel/runtime/helpers/objectSpread2';
import _defineProperty from '@babel/runtime/helpers/defineProperty';
import { getBase64EncodedWireTransaction, getBase64Decoder, getBase58Encoder, getTransactionDecoder, getBase64Encoder, getBase58Decoder } from '@solana/kit';
import { SolanaSignTransaction, SolanaSignMessage, SolanaSignAndSendTransaction } from '@solana/wallet-standard-features';
import { StandardEvents, StandardDisconnect, StandardConnect } from '@wallet-standard/features';
import { SOLANA_METHOD_TYPES } from '@web3auth/ws-embed';
import { sendJrpcRequest, getSolanaAccounts } from './walletConnectV2Utils.js';
import { WEB3AUTH_ICON } from '../../base/wallet/index.js';
import { SOLANA_CAIP_CHAIN_MAP } from '../../base/constants.js';
import { getSolanaChainByChainConfig } from '../../base/wallet/solana.js';

const base58Encoder = getBase58Encoder();
const base58Decoder = getBase58Decoder();
const base64Decoder = getBase64Decoder();
const base64Encoder = getBase64Encoder();
const transactionDecoder = getTransactionDecoder();
/**
 * WCSolanaWallet implements the Wallet Standard interface by routing directly to
 * a WalletConnect SignClient — no intermediate JRPC engine needed.
 */
class WCSolanaWallet {
  constructor(connector, wcCaipChainId, chainIdentifier, accounts) {
    _defineProperty(this, "version", "1.0.0");
    _defineProperty(this, "name", "WalletConnect");
    _defineProperty(this, "icon", WEB3AUTH_ICON);
    _defineProperty(this, "chains", void 0);
    _defineProperty(this, "features", void 0);
    _defineProperty(this, "_accounts", void 0);
    _defineProperty(this, "_listeners", {});
    this.chains = chainIdentifier ? [chainIdentifier] : [];
    this._accounts = accounts;
    this.features = {
      [StandardConnect]: {
        version: "1.0.0",
        connect: async () => ({
          accounts: this._accounts
        })
      },
      [StandardDisconnect]: {
        version: "1.0.0",
        disconnect: async () => {}
      },
      [StandardEvents]: {
        version: "1.0.0",
        on: (event, listener) => {
          var _this$_listeners, _this$_listeners$even;
          ((_this$_listeners$even = (_this$_listeners = this._listeners)[event]) !== null && _this$_listeners$even !== void 0 ? _this$_listeners$even : _this$_listeners[event] = new Set()).add(listener);
          return () => this._listeners[event].delete(listener);
        }
      },
      [SolanaSignAndSendTransaction]: {
        version: "1.0.0",
        supportedTransactionVersions: ["legacy", 0],
        signAndSendTransaction: async (...inputs) => {
          return Promise.all(inputs.map(async input => {
            const base64Tx = base64Decoder.decode(input.transaction);
            const result = await sendJrpcRequest(connector, wcCaipChainId, "solana_signAndSendTransaction", {
              transaction: base64Tx
            });
            return {
              signature: new Uint8Array(base58Encoder.encode(result.signature))
            };
          }));
        }
      },
      [SolanaSignMessage]: {
        version: "1.0.0",
        signMessage: async (...inputs) => {
          return Promise.all(inputs.map(async input => {
            const base58Message = base58Decoder.decode(new Uint8Array(input.message));
            const result = await sendJrpcRequest(connector, wcCaipChainId, SOLANA_METHOD_TYPES.SIGN_MESSAGE, {
              message: base58Message
            });
            return {
              signedMessage: new Uint8Array(input.message),
              signature: new Uint8Array(base58Encoder.encode(result.signature))
            };
          }));
        }
      },
      [SolanaSignTransaction]: {
        version: "1.0.0",
        supportedTransactionVersions: ["legacy", 0],
        signTransaction: async (...inputs) => {
          return Promise.all(inputs.map(async input => {
            const base64Tx = base64Decoder.decode(input.transaction);
            const result = await sendJrpcRequest(connector, wcCaipChainId, SOLANA_METHOD_TYPES.SIGN_TRANSACTION, {
              transaction: base64Tx
            });
            // Reconstruct signed transaction by inserting signature into decoded tx
            const sigBytes = new Uint8Array(base58Encoder.encode(result.signature));
            const decodedTx = transactionDecoder.decode(input.transaction);
            const signedTx = _objectSpread(_objectSpread({}, decodedTx), {}, {
              signatures: _objectSpread(_objectSpread({}, decodedTx.signatures), {}, {
                [input.account.address]: sigBytes
              })
            });
            const signedBase64 = getBase64EncodedWireTransaction(signedTx);
            return {
              signedTransaction: new Uint8Array(base64Encoder.encode(signedBase64))
            };
          }));
        }
      }
    };
  }
  get accounts() {
    return this._accounts;
  }

  /**
   * Creates a WCSolanaWallet by reading accounts from the active WC session.
   */
  static async create(connector, chainConfig) {
    const chainIdentifier = getSolanaChainByChainConfig(chainConfig);
    const wcCaipChainId = `solana:${SOLANA_CAIP_CHAIN_MAP[chainConfig.chainId]}`;
    const addresses = await getSolanaAccounts(connector);
    if (!addresses.length) return null;
    const accountFeatures = [SolanaSignAndSendTransaction, SolanaSignMessage, SolanaSignTransaction];
    const accounts = addresses.map(address => ({
      address,
      publicKey: new Uint8Array(base58Encoder.encode(address)),
      chains: chainIdentifier ? [chainIdentifier] : [],
      features: accountFeatures
    }));
    return new WCSolanaWallet(connector, wcCaipChainId, chainIdentifier, accounts);
  }
}

export { WCSolanaWallet };