init

Author: Nasus

.gitignore

@@ -0,0 +1,2 @@
+dist/
+node_modules/

README.md

@@ -0,0 +1,14 @@
+# SOLANA USDC 批量转账
+## 安装依赖
+```bash
+npm i --save
+```
+## 导入私钥
+将私钥粘贴至`main.ts`21行 `privateKey`
+## 导入收款人列表
+将收款人钱包地址及接收数量粘贴至`main.ts`28行 `addresses`对象内
+## 运行
+```bash
+tsc
+npm run dev
+```

package.json

@@ -0,0 +1,25 @@
+{
+  "name": "solanabatchtransfer",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "debug": "node --inspect-brk dist/main.js",
+    "dev": "node  dist/main.js"
+
+  },
+  "author": "Nasus",
+  "license": "ISC",
+  "dependencies": {
+    "@project-serum/borsh": "^0.2.2",
+    "@solana/web3.js": "^1.20.0",
+    "bs58": "^5.0.0",
+    "buffer-layout": "^1.2.1"
+  },
+  "devDependencies": {
+    "@types/node": "^15.12.4",
+    "ts-node": "^10.0.0",
+    "typescript": "^4.3.4"
+  }
+}

src/main.ts

@@ -0,0 +1,108 @@
+import {
+    Connection,
+    PublicKey,
+    Transaction,
+    Keypair,
+    sendAndConfirmTransaction
+} from "@solana/web3.js";
+import {
+    transferToken,
+    findAssociatedTokenAddress,
+    createAssociatedTokenAccount,
+    TOKEN_ACCOUNT_LAYOUT,
+} from "./utils";
+import * as base58 from 'bs58';
+const connection = new Connection(`https://solana-api.projectserum.com`, { confirmTransactionInitialTimeout: 2 * 60 * 1000 });
+
+const USDC = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+/**
+ * 私钥
+ */
+const privateKey = ``;
+const WALLET = Keypair.fromSecretKey(base58.decode(privateKey), { skipValidation: false });
+const OWNER = WALLET.publicKey;
+const secreKey = WALLET.secretKey;
+console.log(`私钥还原: ${base58.encode(secreKey)}`);
+console.log(`公钥: ${OWNER.toBase58()}`);
+
+const addresses: { [addr: string]: number } = {
+    "address": 1,
+    "3iVeyGyBAfxyrDBApHPGmPksDAEMNqKvmF4Dd5wWjFwX": 1,
+    // "4BQcjumDTD9iyznDT7RNfD1ZwcpKdepRLa7uMooSwpyi": 2,
+};
+
+async function main() {
+    for (const [addr, amount] of Object.entries(addresses)) {
+        console.log(`${addr}: ${amount}`);
+
+        let destinationAddress: PublicKey;
+        let destinationOwner: PublicKey;
+
+        let address = null;
+        try {
+            address = new PublicKey(addr);
+        } catch (error) {
+            console.error(error);
+        }
+        if (!address) {
+            continue;
+        }
+        const addressInfo = await connection.getAccountInfo(address);
+
+        if (!addressInfo || addressInfo.data.length === 0) {
+            destinationOwner = address;
+            destinationAddress = await findAssociatedTokenAddress(
+                destinationOwner,
+                USDC
+            );
+        } else if (addressInfo.data.length === TOKEN_ACCOUNT_LAYOUT.span) {
+            const { mint, owner } = TOKEN_ACCOUNT_LAYOUT.decode(addressInfo.data);
+
+            if (!USDC.equals(mint)) {
+                throw new Error(`invalid address: ${addr} is not USDC token account`);
+            }
+
+            destinationAddress = address;
+            destinationOwner = owner;
+        } else {
+            throw new Error(`invalid address: ${addr}`);
+        }
+
+        const recentBlockhash = await connection.getLatestBlockhash();
+
+        const transaction = new Transaction({
+            recentBlockhash: recentBlockhash.blockhash,
+        });
+
+        const tokenAccountInfo = await connection.getAccountInfo(
+            destinationAddress
+        );
+        if (!tokenAccountInfo) {
+            transaction.add(
+                await createAssociatedTokenAccount(OWNER, USDC, destinationOwner)
+            );
+        }
+
+        const source = await findAssociatedTokenAddress(OWNER, USDC);
+        transaction.add(
+            transferToken({
+                source,
+                dest: destinationAddress,
+                amount: amount * 10 ** 6,
+                owner: OWNER,
+            })
+        );
+        transaction.sign(WALLET);
+        let signature = await sendAndConfirmTransaction(
+            connection,
+            transaction,
+            [WALLET],
+        );
+        // const txid = await connection.sendTransaction(transaction, [WALLET], {
+        //     skipPreflight: false,
+        // });
+        console.log(`${addr}, ${amount} USDC, txid: https://solscan.io/tx/${signature}`);
+    }
+}
+
+main();

src/utils.ts

@@ -0,0 +1,182 @@
+import { PublicKey, PublicKeyInitData, TransactionInstruction } from "@solana/web3.js";
+import { nu64 } from "buffer-layout";
+import { publicKey, struct, u32, u64, u8 } from "@project-serum/borsh";
+
+export const SYSTEM_PROGRAM_ID = new PublicKey(
+    "11111111111111111111111111111111"
+);
+export const TOKEN_PROGRAM_ID = new PublicKey(
+    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
+);
+export const MEMO_PROGRAM_ID = new PublicKey(
+    "Memo1UhkJRfHyvLMcVucJwxXeuD728EqVDDwQDxFMNo"
+);
+export const RENT_PROGRAM_ID = new PublicKey(
+    "SysvarRent111111111111111111111111111111111"
+);
+export const CLOCK_PROGRAM_ID = new PublicKey(
+    "SysvarC1ock11111111111111111111111111111111"
+);
+export const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey(
+    "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL"
+);
+
+export const TOKEN_ACCOUNT_LAYOUT = struct([
+    publicKey("mint"),
+    publicKey("owner"),
+    u64("amount"),
+    u32("delegateOption"),
+    publicKey("delegate"),
+    u8("state"),
+    u32("isNativeOption"),
+    u64("isNative"),
+    u64("delegatedAmount"),
+    u32("closeAuthorityOption"),
+    publicKey("closeAuthority"),
+]);
+
+export function isValidPublicKey(key: PublicKeyInitData) {
+    if (!key) {
+        return false;
+    }
+    try {
+        new PublicKey(key);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export async function findProgramAddress(
+    seeds: Array<Buffer | Uint8Array>,
+    programId: PublicKey
+) {
+    const [publicKey, nonce] = await PublicKey.findProgramAddress(
+        seeds,
+        programId
+    );
+    return { publicKey, nonce };
+}
+/**
+ * 查找用户spl—token账户地址
+ * @param walletAddress 用户钱包地址
+ * @param tokenMintAddress USDC Token 地址
+ * @returns 
+ */
+export async function findAssociatedTokenAddress(
+    walletAddress: PublicKey,
+    tokenMintAddress: PublicKey
+) {
+    const { publicKey } = await findProgramAddress(
+        [
+            walletAddress.toBuffer(),
+            TOKEN_PROGRAM_ID.toBuffer(),
+            tokenMintAddress.toBuffer(),
+        ],
+        ASSOCIATED_TOKEN_PROGRAM_ID
+    );
+    return publicKey;
+}
+
+export async function createAssociatedTokenAccount(
+    payer: PublicKey,
+    tokenMintAddress: PublicKey,
+    owner: PublicKey
+) {
+    const associatedTokenAddress = await findAssociatedTokenAddress(
+        owner,
+        tokenMintAddress
+    );
+
+    const keys = [
+        {
+            pubkey: payer,
+            isSigner: true,
+            isWritable: true,
+        },
+        {
+            pubkey: associatedTokenAddress,
+            isSigner: false,
+            isWritable: true,
+        },
+        {
+            pubkey: owner,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: tokenMintAddress,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: SYSTEM_PROGRAM_ID,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: TOKEN_PROGRAM_ID,
+            isSigner: false,
+            isWritable: false,
+        },
+        {
+            pubkey: RENT_PROGRAM_ID,
+            isSigner: false,
+            isWritable: false,
+        },
+    ];
+
+    return new TransactionInstruction({
+        keys,
+        programId: ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: Buffer.from([]),
+    });
+}
+/**
+ * 转账交易
+ * @param param
+ * @returns 
+ */
+export function transferToken(param: ITransferTokenParams) {
+    let keys = [
+        { pubkey: param.source, isSigner: false, isWritable: true },
+        { pubkey: param.dest, isSigner: false, isWritable: true },
+        { pubkey: param.owner, isSigner: true, isWritable: false },
+    ];
+
+    const layout = struct([u8("instruction"), nu64("amount")]);
+
+    const data = Buffer.alloc(layout.span);
+    layout.encode(
+        {
+            instruction: 3,
+            amount: param.amount,
+        },
+        data
+    );
+
+    return new TransactionInstruction({
+        keys,
+        data,
+        programId: TOKEN_PROGRAM_ID,
+    });
+}
+
+interface ITransferTokenParams {
+    /**
+     * 转账源账户
+     */
+    source: PublicKey;
+    /**
+     * 转账目标账户
+     */
+    dest: PublicKey;
+    /**
+     * 转账人公钥
+     */
+    owner: PublicKey;
+    /**
+     * 转账金额
+     */
+    amount: number;
+}

tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "ts-node": {
+    "compilerOptions": {
+      "module": "commonjs"
+    }
+  },
+  "compilerOptions": {
+    "declaration": true,
+    "moduleResolution": "node",
+    "module": "commonjs",
+    "target": "es2021",
+    "experimentalDecorators": true,
+    "outDir": "dist",
+    "forceConsistentCasingInFileNames": true,
+    "sourceMap": true,
+    "allowJs": true
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}