feat: udt:transfer, udt:extended:mint, udt:pausable initial implementation (WIP)

Author: chunteng-web3

.env

@@ -0,0 +1,3 @@
+MAIN_WALLET_PRIVATE_KEY=c0f0166fbbabca125cd8f9e12ddde5bc204fcbdbb090d6c1eb3a29bc028029e6
+PAUSED_WALLET_PRIVATE_KEY=38ef35ae58d854676f7822623f5e2b3ec4284766323be6750e32e2f0ec44eed4
+CKB_RPC_URL=wss://testnet.ckb.dev/ws

package.json

@@ -12,7 +12,8 @@
     "@oclif/core": "^4",
     "@oclif/plugin-help": "^6",
     "@oclif/plugin-plugins": "^5",
-    "axios": "^1.7.7"
+    "axios": "^1.7.7",
+    "dotenv": "^16.4.5"
   },
   "devDependencies": {
     "@oclif/prettier-config": "^0.2.1",

pnpm-lock.yaml

@@ -1,4 +1,5 @@
 import {Args, Command, Flags} from '@oclif/core'
+import { encodeU832Array } from '../../libs/utils'
 
 export default class Hello extends Command {
   static args = {

src/commands/hello/index.ts

@@ -0,0 +1,77 @@
+import { ccc, Cell, CellDep, CellDepLike } from '@ckb-ccc/core'
+import {Args, Command, Flags} from '@oclif/core'
+import { getUDTConfig } from '../../../libs/config.js'
+import 'dotenv/config'
+
+export default class UdtExtendedMint extends Command {
+  static override args = {
+  }
+
+  static override description = 'describe the command here'
+
+  static override examples = [
+    '<%= config.bin %> <%= command.id %>',
+  ]
+
+  static override flags = {
+    // flag with no value (-f, --force)
+    force: Flags.boolean({char: 'f'}),
+    // flag with a value (-n, --name=VALUE)
+    name: Flags.string({char: 'n', description: 'name to print'}),
+  }
+
+  public async run(): Promise<void> {
+    const {args, flags} = await this.parse(UdtExtendedMint)
+
+    const client = new ccc.ClientPublicTestnet({ url: process.env.CKB_RPC_URL });
+    const signer = new ccc.SignerCkbPrivateKey(
+      client,
+      process.env.MAIN_WALLET_PRIVATE_KEY!,
+    );
+
+    const recommendedActorAddress = await signer.getRecommendedAddress();
+    const { script: ownerLock } = await signer.getRecommendedAddressObj();
+
+    const toAddress = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqgtlcnzzna2tqst7jw78egjpujn7hdxpackjmmdp";
+    const toLock = (await ccc.Address.fromString(toAddress, signer.client)).script;
+
+    const udtConfig = getUDTConfig();
+    const udtTypeScript = new ccc.Script(
+      udtConfig.code_hash,
+      'type',
+      udtConfig.args
+    );
+
+    const mintTx = ccc.Transaction.from({
+      outputs: [
+        {
+          lock: toLock,
+          type: udtTypeScript,
+        },
+      ],
+      outputsData: [
+        ccc.numLeToBytes(100000000, 16)
+      ]
+    });
+
+    await mintTx.completeInputsByCapacity(signer);
+    await mintTx.completeFeeBy(signer);
+
+    console.log(mintTx.inputs[0]);
+
+    const findCellDepResult = await client.findCells(udtConfig.cellDepSearchKey).next();
+    const cellDepCell: Cell = findCellDepResult.value;
+    const cellDepLike: CellDepLike = {
+      outPoint: {
+        txHash: cellDepCell.outPoint.txHash,
+        index: cellDepCell.outPoint.index,
+      },
+      depType: 'code',
+    };
+
+    mintTx.addCellDeps(cellDepLike);
+    const mintTxHash = await signer.sendTransaction(mintTx);
+
+    console.log(`Minted UDT with transaction hash: ${mintTxHash}`);
+  }
+}

src/commands/udt/extended/mint.ts

@@ -0,0 +1,63 @@
+import {HasherCkb, numToBytes, numToHex} from '@ckb-ccc/core'
+import {Args, Command, Flags} from '@oclif/core'
+import {cccA} from '@ckb-ccc/core/advanced'
+import { encodeHex, encodeU832Array } from '../../../libs/utils.js'
+import axios from 'axios'
+
+export default class UdtPausableIsPaused extends Command {
+  static override args = {
+  }
+
+  static strict = false;
+
+  static override description = 'describe the command here'
+
+  static override examples = ['<%= config.bin %> <%= command.id %>']
+
+  static override flags = {
+    target: Flags.string({description: 'Target cell'}),
+    index: Flags.integer({description: 'Index of the target cell'}),
+    level: Flags.string({
+      char: 'l',
+      description: 'name to print',
+      options: ['code', 'cell', 'transaction'],
+      default: 'code',
+    }),
+  }
+
+  public async run(): Promise<void> {
+    const {argv, flags} = await this.parse(UdtPausableIsPaused)
+    // Method path hex function
+    const hasher = new HasherCkb();
+    const enumeratePausedPathHex = hasher.update(Buffer.from('UDT.enumerate_paused')).digest().slice(0, 18);
+    console.debug('hashed method path hex:', enumeratePausedPathHex);
+
+    // Define URL
+    const url = 'http://localhost:9090';
+
+    // Define the JSON payload
+    const payload = {
+      id: 2,
+      jsonrpc: '2.0',
+      method: 'run_script_level_code',
+      params: [
+        "0x24e477bdae84955713ce9075cc176e87f1c882fa3cedcde4ea3dd6c1ee7b0d5c",
+        // args.target, 
+        0,
+        // args.index, 
+        [enumeratePausedPathHex,]],
+    };
+
+    // Send POST request
+    axios
+      .post(url, payload, {
+        headers: {'Content-Type': 'application/json'},
+      })
+      .then((response) => {
+        console.log('Response JSON:', response.data)
+      })
+      .catch((error) => {
+        console.error('Request failed', error)
+      })
+  }
+}

src/commands/udt/pausable/enumerate-paused.ts

@@ -1,12 +1,11 @@
 import {HasherCkb, numToBytes, numToHex} from '@ckb-ccc/core'
 import {Args, Command, Flags} from '@oclif/core'
 import {cccA} from '@ckb-ccc/core/advanced'
+import { encodeHex, encodeU832Array } from '../../../libs/utils.js'
 import axios from 'axios'
 
 export default class UdtPausableIsPaused extends Command {
   static override args = {
-    target: Args.string({description: 'Target cell'}),
-    index: Args.integer({description: 'Index of the target cell'}),
     lock_hash: Args.string({description: 'Lock hash in hex. Variable length'}),
   }
 
@@ -17,6 +16,8 @@ export default class UdtPausableIsPaused extends Command {
   static override examples = ['<%= config.bin %> <%= command.id %>']
 
   static override flags = {
+    target: Flags.string({description: 'Target cell'}),
+    index: Flags.integer({description: 'Index of the target cell'}),
     level: Flags.string({
       char: 'l',
       description: 'name to print',
@@ -25,55 +26,16 @@ export default class UdtPausableIsPaused extends Command {
     }),
   }
 
-  public encodeU832Array(val: Array<Uint8Array>): Uint8Array {
-    if (val.some((arr) => arr.length !== 32)) {
-      throw new Error('Each inner array must be exactly 32 bytes.')
-    }
-
-    // Convert the length to a 4-byte little-endian array
-    const lengthBytes = new Uint8Array(new Uint32Array([val.length]).buffer)
-    console.log('lengthBytes:', lengthBytes);
-
-    // Flatten the 2D array of 32-byte elements into a single array
-    const flattenedBytes = val.reduce((acc, curr) => {
-      acc.push(...curr)
-      return acc
-    }, [] as number[])
-
-    // Combine the length bytes with the flattened byte array
-    return new Uint8Array([...lengthBytes, ...flattenedBytes])
-  }
-
-  public encodeHex(data: Uint8Array): string {
-    // Convert each byte to a two-character hex string
-    return Array.from(data, byte => byte.toString(16).padStart(2, '0')).join('');
-  }
-  
-  public decodeHex(data: string): Uint8Array {
-    if (data.length % 2 !== 0) {
-      throw new Error("Invalid hex string: must have an even length.");
-    }
-  
-    // Convert the hex string into a Uint8Array
-    const result = new Uint8Array(data.length / 2);
-    for (let i = 0; i < data.length; i += 2) {
-      result[i / 2] = parseInt(data.slice(i, i + 2), 16);
-    }
-  
-    return result;
-  }
-  
   public async run(): Promise<void> {
     const {argv, flags} = await this.parse(UdtPausableIsPaused)
     let lockHashU832Array = [];
-    console.log('argv:', argv);
     for (const lock_hash of argv) {
       lockHashU832Array.push(numToBytes(String(lock_hash), 32).reverse());
     }
-    console.log('lockHashU832Array:', lockHashU832Array);
-    const lockHashU832ArrayEncoded = this.encodeU832Array(lockHashU832Array);
-    console.log('lockHashArrayEncoded:', lockHashU832ArrayEncoded);
-    const lockHashU832ArrayEncodedHex = this.encodeHex(lockHashU832ArrayEncoded);
+    console.debug('lockHashU832Array:', lockHashU832Array);
+    const lockHashU832ArrayEncoded = encodeU832Array(lockHashU832Array);
+    console.debug('lockHashArrayEncoded:', lockHashU832ArrayEncoded);
+    const lockHashU832ArrayEncodedHex = encodeHex(lockHashU832ArrayEncoded);
 
     // Method path hex function
     const hasher = new HasherCkb();
@@ -89,7 +51,7 @@ export default class UdtPausableIsPaused extends Command {
       jsonrpc: '2.0',
       method: 'run_script_level_code',
       params: [
-        "0xe06146dc630f96b3fb0a6cbaf81350b87aa8f195745bdf21d6d4f6de2f53d0cc",
+        "0x24e477bdae84955713ce9075cc176e87f1c882fa3cedcde4ea3dd6c1ee7b0d5c",
         // args.target, 
         0,
         // args.index, 

src/commands/udt/pausable/is-paused.ts

@@ -1,4 +1,6 @@
+import { ccc, Cell, CellDepLike } from '@ckb-ccc/core'
 import {Args, Command, Flags} from '@oclif/core'
+import { getUDTConfig } from '../../libs/config.js'
 
 export default class UdtTransfer extends Command {
   static override args = {
@@ -20,7 +22,55 @@ export default class UdtTransfer extends Command {
   // TODO: Get signer
   public async run(): Promise<void> {
     const {args, flags} = await this.parse(UdtTransfer);
-    // const newToAddress = ccc.Address.fromString(args.toAddress!, signer.client);
+
+    const client = new ccc.ClientPublicTestnet({ url: process.env.CKB_RPC_URL });
+    const signer = new ccc.SignerCkbPrivateKey(
+      client,
+      process.env.PAUSED_WALLET_PRIVATE_KEY!,
+    );
+    const toAddress = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqtxe0gs9yvwrsc40znvdc6sg4fehd2mttsngg4t4";
+    const toLock = (await ccc.Address.fromString(toAddress, signer.client)).script;
 
+    const udtConfig = getUDTConfig();
+    const udtTypeScript = new ccc.Script(
+      udtConfig.code_hash,
+      'type',
+      udtConfig.args
+    );
+
+    const transferTx = ccc.Transaction.from({
+      outputs: [
+        {
+          lock: toLock,
+          type: udtTypeScript,
+        },
+      ],
+      outputsData: [
+        ccc.numLeToBytes(50000000, 16)
+      ]
+    });
+    await transferTx.completeInputsByUdt(signer, udtTypeScript);
+    await transferTx.completeInputsByCapacity(signer);
+    await transferTx.completeFeeBy(signer);
+
+    const findCellDepResult = await client.findCells(udtConfig.cellDepSearchKey).next();
+    const cellDepCell: Cell = findCellDepResult.value;
+    const cellDepLike: CellDepLike = {
+      outPoint: {
+        txHash: cellDepCell.outPoint.txHash,
+        index: cellDepCell.outPoint.index,
+      },
+      depType: 'code',
+    };
+
+    transferTx.addCellDeps(cellDepLike);
+    const transferTxTxHash = await signer.sendTransaction(transferTx);
+
+    console.log(`Minted UDT with transaction hash: ${transferTxTxHash}`);
+
   }
+
+  // TODO: Traditional transferring for pausable-udt
+
+  // TODO: SSRI transferring for pausable-udt
 }

src/commands/udt/transfer.ts

@@ -1 +1,2 @@
-export {run} from '@oclif/core'
+
+export {run} from '@oclif/core';