feat(cli): add top-level blesstoken-disable-mint command

README.md

@@ -197,7 +197,7 @@ Following is the help message.
 ```bash
 Usage: @blessnetwork/blesscontract blesstoken [options] <wallets> <mint> <mintAuthority>
 
-blesstoken: initial blesstoken registration
+blesstoken: initial blesstoken token mint and disptch bless token to wallet1-5 by rules.
 
 Arguments:
   wallets              wallets: wallets is the wallet 1-5 that distrubuted the bless token by the contract, value should be base58 sperate by `,`.
@@ -208,7 +208,22 @@ Arguments:
 
 Options:
   --cluster <cluster>  solana cluster: mainnet, testnet, devnet, localnet, <custom>
+  --programId <programId>                     Program ID: Specify the program ID when working on devnet, testnet, or localnet; it will not work on mainnet.
+  --payer <payer>                             the default payer: ~/.config/solana/id.json
   -h, --help           display help for command
+
+```
+
+Execute the following command to get the blesstoken-disable-mint help message.
+
+```bash
+npx @blessnetwork/blesscontract blesstoken-disable-mint --help
+```
+
+Execute the following command to disable mint authority.
+
+```bash
+npx @blessnetwork/blesscontract blesstoken-disable-mint <mint>
 ```
 
 1. Prepare the Mint Authory Keypair.

command/bles_meta_create.js

@@ -25,7 +25,6 @@ const blessMetaCreateCommand = new Command("create")
     "signer: the signer is the payer of the bless meta, default: " +
       WALLET_PATH,
   )
-  .option("--multisig <multisig>", "multisig:  the multisig of the bless meta")
   .option(
     "--squads <true/false>",
     "squads: if squads true, use squads to signature, default is false.",
@@ -62,15 +61,6 @@ blessMetaCreateCommand
       const state =
         await client.blessTokenClient.getBlessTokenMetaState(mintPubkey);
       if (options.squads) {
-        if (options.multisig == null) {
-          console.log(chalk.red("multisig is required."));
-          process.exit(1);
-        }
-        const multisigPda = new PublicKey(options.multisig);
-        if (options.admin == null) {
-          console.log(chalk.red("admin is required."));
-          process.exit(1);
-        }
         const adminPubkey = new PublicKey(options.admin);
         if (state.admin.toBase58() != adminPubkey.toBase58()) {
           console.log(

command/blesstoken_disable_mint.js

@@ -0,0 +1,119 @@
+const { Command, Argument } = require("commander");
+const {
+  getBlsContractClient,
+  getPath,
+  readKeypair,
+  bs58Message,
+} = require("./utils");
+const { WALLET_PATH } = require("../lib/constants");
+const chalk = require("chalk");
+const { PublicKey } = require("@solana/web3.js");
+const BLESS_CONTRACT_STATE_SEED = "bless_contract_state";
+
+const blessTokenDisableMintCommand = new Command("blesstoken-disable-mint")
+  .alias("blesstoken_disable_mint")
+  .alias("disable-mint")
+  .alias("disable_mint")
+  .option(
+    "--cluster <cluster>",
+    "solana cluster: mainnet, testnet, devnet, localnet, <custom>",
+  )
+  .option(
+    "--signer <signer>",
+    "the signer is the payer/admin of bless token meta: " + WALLET_PATH,
+  )
+  .option(
+    "--programId <programId>",
+    "Program ID: Specify the program ID when working on devnet, testnet, or localnet; it will not work on mainnet.",
+  )
+  .option(
+    "--squads <true/false>",
+    "squads: if squads true, use squads to signature, default is false.",
+  )
+  .option("--admin <admin>", "admin pubkey when using squads mode.")
+  .description("disable-mint: disable bless token mint authority.");
+
+const mint = new Argument(
+  "mint",
+  "mint: the mint is the mint token base58 value ",
+);
+mint.required = true;
+
+blessTokenDisableMintCommand.addArgument(mint).action(async (mint, options) => {
+  options.cluster = options.cluster || "localnet";
+  options.signer = options.signer || getPath(WALLET_PATH);
+  try {
+    const keypair = readKeypair(options.signer);
+    let mintPubkey = null;
+    try {
+      mintPubkey = new PublicKey(mint);
+    } catch (e) {
+      console.log(chalk.red("invaild mint parameter: " + e));
+      process.exit(1);
+    }
+    const client = getBlsContractClient(
+      options.cluster,
+      keypair,
+      options.programId,
+    );
+    const [blessStatePda] = PublicKey.findProgramAddressSync(
+      [Buffer.from(BLESS_CONTRACT_STATE_SEED), mintPubkey.toBuffer()],
+      client.programId,
+    );
+    const state = await client.blessTokenClient.getBlessTokenMetaState(mintPubkey);
+
+    if (options.squads) {
+      if (options.admin == null) {
+        console.log(chalk.red("admin is required."));
+        process.exit(1);
+      }
+      const admin = new PublicKey(options.admin);
+      if (state.admin.toBase58() != admin.toBase58()) {
+        console.log(
+          chalk.red(
+            "disable mint is denied, admin is not matched, the state admin is " +
+              state.admin.toBase58(),
+          ),
+        );
+        process.exit(1);
+      }
+      const tx = await client.blessTokenClient.getDisableMintTx(
+        mintPubkey,
+        { signer: admin },
+      );
+      const itx = await bs58Message(
+        client.connection,
+        tx.instructions,
+        keypair,
+      );
+      console.log("bless token disable mint transaction created: \n" + itx);
+    } else {
+      if (state.admin.toBase58() != keypair.publicKey.toBase58()) {
+        console.log(
+          chalk.red(
+            "disable mint is denied, admin is not matched, the state admin is " +
+              state.admin.toBase58(),
+          ),
+        );
+        process.exit(1);
+      }
+
+      await client.blessTokenClient.disableMint(
+        mintPubkey,
+        blessStatePda,
+        {
+          signer: keypair.publicKey,
+          signerKeypair: [keypair],
+        },
+      );
+      console.log(chalk.green("disable mint success."));
+      process.exit(0);
+    }
+  } catch (e) {
+    console.log(e);
+    console.log(chalk.red("disable mint fail: " + e));
+    process.exit(1);
+  }
+});
+
+module.exports = blessTokenDisableMintCommand;

command/loader.js

@@ -40,6 +40,14 @@ function encodeInstruction(data) {
   dataLayout.addVariant(3, BufferLayout.struct([]), "Upgrade");
   dataLayout.addVariant(4, BufferLayout.struct([]), "SetAuthority");
   dataLayout.addVariant(5, BufferLayout.struct([]), "Close");
+  const extendProgram = BufferLayout.struct([
+    BufferLayout.u32("additional_bytes"),
+  ]);
+  dataLayout.addVariant(6, extendProgram, "ExtendProgram");
+  const extendProgramChecked = BufferLayout.struct([
+    BufferLayout.u32("additional_bytes"),
+  ]);
+  dataLayout.addVariant(9, extendProgramChecked, "ExtendProgramChecked");
 
   // UpgradeableLoaderInstruction tag + offset + chunk length + chunk data
   const instructionBuffer = Buffer.alloc(4 + 4 + 8 + Loader.chunkSize);
@@ -174,6 +182,58 @@ class Loader {
     });
   }
 
+  static async extendProgramInstruction(program, payer, additionalBytes) {
+    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
+      [program.toBuffer()],
+      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
+    );
+    return new TransactionInstruction({
+      keys: [
+        { pubkey: programDataKey, isSigner: false, isWritable: true },
+        { pubkey: program, isSigner: false, isWritable: true },
+        {
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false,
+        },
+        { pubkey: payer, isSigner: true, isWritable: true },
+      ],
+      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
+      data: encodeInstruction({
+        ExtendProgram: { additional_bytes: additionalBytes },
+      }),
+    });
+  }
+
+  static async extendProgramCheckedInstruction(
+    program,
+    authority,
+    payer,
+    additionalBytes,
+  ) {
+    const [programDataKey, _nonce] = PublicKey.findProgramAddressSync(
+      [program.toBuffer()],
+      UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
+    );
+    return new TransactionInstruction({
+      keys: [
+        { pubkey: programDataKey, isSigner: false, isWritable: true },
+        { pubkey: program, isSigner: false, isWritable: true },
+        { pubkey: authority, isSigner: true, isWritable: false },
+        {
+          pubkey: SystemProgram.programId,
+          isSigner: false,
+          isWritable: false,
+        },
+        { pubkey: payer, isSigner: true, isWritable: true },
+      ],
+      programId: UPGRADEABLE_BPF_LOADER_PROGRAM_ID,
+      data: encodeInstruction({
+        ExtendProgramChecked: { additional_bytes: additionalBytes },
+      }),
+    });
+  }
+
   static async getDeployBufferTransaction(
     connection,
     payer,

command/prg_extend.js

@@ -0,0 +1,147 @@
+const { Command, Argument } = require("commander");
+const { getPath, readKeypair, getConnection, bs58Message } = require("./utils");
+const { WALLET_PATH } = require("../lib/constants");
+const Loader = require("./loader");
+const chalk = require("chalk");
+const { bs58 } = require("@coral-xyz/anchor/dist/cjs/utils/bytes");
+const { PublicKey, Transaction, TransactionInstruction, SystemProgram } = require("@solana/web3.js");
+
+const extendCommand = new Command("extend")
+  .option(
+    "--cluster <cluster>",
+    "solana cluster: mainnet, testnet, devnet, localnet, <custom>",
+  )
+  .option("--payer <payer>", "the default payer: " + WALLET_PATH)
+  .option(
+    "--authority <authority>",
+    "the authority keypair file (default: " + WALLET_PATH + ")",
+  )
+  .option(
+    "--squads <true/false>",
+    "squads: if squads true, create a tx message for squads signing, default is false.",
+  )
+  .option(
+    "--admin <admin>",
+    "admin: payer pubkey when using squads mode.",
+  )
+  .description("extend: extend an upgradeable program data account");
+
+const programId = new Argument(
+  "programId",
+  "programId: the program id (base58 value)",
+);
+const additionalBytes = new Argument(
+  "additionalBytes",
+  "additionalBytes: extra bytes to add to the ProgramData account",
+);
+
+extendCommand
+  .addArgument(programId)
+  .addArgument(additionalBytes)
+  .action(async (programId, additionalBytes, options) => {
+    options.payer = options.payer || getPath(WALLET_PATH);
+    options.authority = options.authority || getPath(WALLET_PATH);
+    options.cluster = options.cluster || "localnet";
+    try {
+      const payerKeypair = readKeypair(options.payer);
+      const authorityKeypair = readKeypair(options.authority);
+      const programIdPK = new PublicKey(programId);
+      const additionalBytesNum = Number(additionalBytes);
+      if (
+        !Number.isInteger(additionalBytesNum) ||
+        additionalBytesNum <= 0 ||
+        additionalBytesNum > 0xffffffff
+      ) {
+        throw new Error("additionalBytes must be an integer in [1, 4294967295]");
+      }
+
+      const connection = getConnection(options.cluster);
+      const useSquads =
+        options.squads === true ||
+        options.squads === "true" ||
+        options.squads === 1 ||
+        options.squads === "1";
+      if (useSquads) {
+        const programAccount = await connection.getAccountInfo(programIdPK);
+        if (!programAccount) {
+          throw new Error(`Program account not found: ${programId}`);
+        }
+        const programDataAddress = new PublicKey(
+          programAccount.data.subarray(4, 36),
+        );
+        const PROGRAMDATA_HEADER_SIZE = 45;
+        const programDataAccount = await connection.getAccountInfo(
+          programDataAddress,
+        )
+        if (!programDataAccount) {
+          throw new Error(
+            `ProgramData account not found: ${programDataAddress.toBase58()}`,
+          );
+        }
+
+        const data = Buffer.alloc(8);
+        data.writeUInt32LE(6, 0); // ExtendProgram discriminator
+        data.writeUInt32LE(Math.floor(additionalBytes * 1.05), 4);
+        const BPF_LOADER_UPGRADEABLE = new PublicKey(
+          "BPFLoaderUpgradeab1e11111111111111111111111",
+        );
+        const admin = new PublicKey(options.admin);
+        const ix = new TransactionInstruction({
+          programId: BPF_LOADER_UPGRADEABLE,
+          keys: [
+            { pubkey: programDataAddress, isSigner: false, isWritable: true },
+            {
+              pubkey: new PublicKey(programId),
+              isSigner: false,
+              isWritable: true,
+            },
+            {
+              pubkey: SystemProgram.programId,
+              isSigner: false,
+              isWritable: false,
+            },
+            { pubkey: admin, isSigner: true, isWritable: true },
+          ],
+          data,
+        });
+        const tx = new Transaction().add(ix);
+
+        tx.feePayer = admin;
+        tx.recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+        const serialized = tx.serialize({ verifySignatures: false });
+        console.log("Transaction:", {
+          b64: serialized.toString("base64"),
+          b58: bs58.encode(serialized),
+        });
+        return
+      }
+
+      const extendIx = await Loader.extendProgramCheckedInstruction(
+        programIdPK,
+        authorityKeypair.publicKey,
+        payerKeypair.publicKey,
+        additionalBytesNum,
+      );
+      const transaction = new Transaction();
+      transaction.instructions = [extendIx];
+
+      transaction.recentBlockhash = (
+        await connection.getLatestBlockhash()
+      ).blockhash;
+      transaction.feePayer = payerKeypair.publicKey;
+      if (
+        payerKeypair.publicKey.toBase58() === authorityKeypair.publicKey.toBase58()
+      ) {
+        transaction.sign(payerKeypair);
+      } else {
+        transaction.sign(payerKeypair, authorityKeypair);
+      }
+
+      const tx = await connection.sendRawTransaction(transaction.serialize());
+      console.log(chalk.green("program extend success: " + tx));
+    } catch (e) {
+      console.log(chalk.red("program extend fail: " + e));
+    }
+  });
+
+module.exports = extendCommand;