Solana SDK migration Guide (v1 → @solana/web3.js 2.x)

npm install --save @solana/web3.js@next
# This repository has been archived by the owner on Jan 10, 2025. Could be skipped
npm install --save @solana/spl-token@latest # seems next point to an old version

Finality -> Commitment
connection: Connection ->   rpc: ReturnType<typeof createSolanaRpc>
                       ->   rpcSubscriptions: ReturnType<typeof rpcSubscriptions>

connection: Connection

export const connection = new Connection(process.env.RPC_URL!, {
  wsEndpoint: process.env.RPC_WSS_URL!,
  commitment: 'confirmed',
});

rpc: ReturnType<typeof createSolanaRpc>

export const rpc = createSolanaRpc(process.env.RPC_URL!);
export const rpcSubscriptions = createSolanaRpcSubscriptions(
  process.env.RPC_WSS_URL!
);

export const owner: Keypair = Keypair.fromSecretKey(
  bs58.decode(process.env.WALLET_PRIVATE_KEY!)
);

owner.publicKey -> owner.address

import bs58 from 'bs58';
import { createKeyPairSignerFromBytes, KeyPairSigner } from '@solana/web3.js';

const owner: KeyPairSigner = await createKeyPairSignerFromBytes(
    bs58.decode(process.env.WALLET_PRIVATE_KEY!)
  );

await connection.getAccountInfo(owner.publicKey)

await connection.getTokenAccountsByOwner(
    owner.address,
    { programId: TOKEN_PROGRAM_ID }
  );

await rpc.getAccountInfo(owner.address).send();

await rpc
    .getTokenAccountsByOwner(
      owner.address,
      { programId: address(TOKEN_PROGRAM_ID.toBase58()) },
      { commitment: 'confirmed' }
    )
    .send();

// 1 Crete function `sendAndConfirmTransaction`
// 2 Setup lifetime for a transaction (Every transaction needs to specify a valid lifetime for it to be accepted for execution on the * network.)
// 3 Crete transaction

// 1
const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({
    /**
     * The RPC implements a `sendTransaction` method which relays transactions to the network.
     */
    rpc,
    /**
     * RPC subscriptions allow the transaction sender to subscribe to the status of our transaction.
     * The sender will resolve when the transaction is reported to have been confirmed, or will
     * reject in the event of an error, or a timeout if the transaction lifetime is thought to have
     * expired.
     */
    rpcSubscriptions,
});

const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

const transactionMessage = pipe(
    createTransactionMessage({ version: 0 }),
    tx => setTransactionMessageFeePayer(FEE_PAYER_ADDRESS, tx),
    tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
    tx =>
        appendTransactionMessageInstructions(
            [
                getTransferSolInstruction({
                    amount: lamports(12345678n),
                    destination: DESTINATION_ADDRESS,
                    source: SOURCE_ACCOUNT_SIGNER,
                }),
                getAddMemoInstruction({
                    memo: 'hello from @solana/web3.js',
                }),
            ],
            tx,
        ),
);

{
    encoding: 'base64',
}

const tokenAccountsResponse = await connection
    .getTokenAccountsByOwner(
      ownerPublicKey,
      {
        programId: address('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
      },
      {
        encoding: 'base64',
      }
    )
    .send();

// or

const tokenAccountsResponse = await connection
    .getTokenAccountsByOwner(
      ownerPublicKey,
      {
        programId: address('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
      },
      {
        encoding: 'jsonParsed',
      }
    )
    .send();