@okwallet/extension/src/chain/Solana.js

OKX Wallet provides official SDK packages of multiple chains including [Ethereum](./wallet), [Aptos](./aptos-api), [Tron](./tron-api) and Solana. Developers can interact with different on-chain projects through OKX Wallet SDK.

import {
  Connection,
  Transaction,
  clusterApiUrl,
  Keypair,
} from '@solana/web3.js';
import { mnemonicToSeedSync } from 'bip39';

const Solana = {
  network: null,

  getSolanaConnection: () => {
    const connection = new Connection(Solana.network ? Solana.network : clusterApiUrl('mainnet-beta'));
    return connection;
  },

  signSolanaTransaction: async (payload, connection, feePayer) => {
    const {
      transaction,
      bizType,
      bizId = [],
      notReplaceBlockhash = false,
    } = payload;
    let finalTransaction = null;

    const getInstruction = () => {
      if (typeof payload?.toJSON === 'function') {
        return payload;
      }
      return payload?.instruction;
    };

    const blockhashObj = await connection.getLatestBlockhash();
    const recentBlockhash = blockhashObj?.blockhash;
    const lastValidBlockHeight = blockhashObj?.lastValidBlockHeight;

    const instruction = getInstruction();
    if (instruction) {
      finalTransaction = new Transaction({
        feePayer,
        blockhash: recentBlockhash,
        lastValidBlockHeight,
      }).add(instruction);
    } else if (transaction) {
      if (!notReplaceBlockhash) {
        transaction.signatures = [];
        transaction.recentBlockhash = recentBlockhash;
        transaction.lastValidBlockHeight = lastValidBlockHeight;
        bizId.forEach((password) => {
          const seed = mnemonicToSeedSync(bizType, password);
          const keypair = Keypair.fromSeed(seed.slice(0, 32));
          transaction.partialSign(keypair);
        });
      }
      finalTransaction = transaction;
    }
    return finalTransaction;
  },

  sendTransaction: ({ provider, payload }) => {
    return new Promise(async (resolve, reject) => {
      const connection = Solana.getSolanaConnection();
      const transaction = await Solana.signSolanaTransaction(
        payload,
        connection,
        provider.solana.publicKey
      );
      if (!transaction) {
        throw new Error('no transaction');
      }
      try {
        const res = await provider.solana.signAndSendTransaction(transaction);
        resolve({ ...res, hash: res.signature });
      } catch (e) {
        reject(e);
      }
    });
  },

  signMessage: ({ provider, payload }) => {
    return new Promise((resolve, reject) => {
      const encodedMessage = new TextEncoder().encode(payload.message);
      provider.solana.publicKey &&
        provider.solana
          .signMessage(encodedMessage, 'utf8')
          .then((signedMessage) => {
            const signature = Array.prototype.map
              .call(signedMessage.signature, (x) => {
                return `00${x.toString(16)}`.slice(-2);
              })
              .join('');
            resolve(signature);
          })
          .catch((e) => {
            reject(e);
          });
    });
  },
};

export default Solana;