@offckb/cli 0.1.0-rc3 → 0.1.0-rc5

package/dist/cmd/init.js

@@ -4,12 +4,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.init = void 0;
-const child_process_1 = require("child_process");
 const const_1 = require("../cfg/const");
 const path_1 = __importDefault(require("path"));
-function init(name) {
+const util_1 = require("../util");
+function init(name, template) {
     const targetPath = path_1.default.resolve(const_1.currentExecPath, name);
-    (0, child_process_1.execSync)(`cp -r ${const_1.dappTemplatePath} ${targetPath}`);
-    console.log(`init CKB dapp project with lumos: ${targetPath}`);
+    const sourcePath = path_1.default.resolve(const_1.dappTemplatePath, template);
+    (0, util_1.copyFolderSync)(sourcePath, targetPath);
+    // add some common code files
+    const ckbDotTs = path_1.default.resolve(const_1.dappTemplatePath, 'ckb.ts');
+    const configJson = path_1.default.resolve(const_1.dappTemplatePath, 'config.json');
+    (0, util_1.copyFileSync)(ckbDotTs, targetPath);
+    (0, util_1.copyFileSync)(configJson, targetPath);
+    console.log(`init CKB dapp project: ${targetPath}`);
 }
 exports.init = init;

package/dist/util.d.ts

@@ -1 +1,6 @@
 export declare function isFolderExists(folderPath: string): boolean;
+export declare function copyFolderSync(source: string, destination: string): void;
+export declare function copyFileSync(source: string, target: string): void;
+export declare function copyFilesWithExclusion(sourceDir: string, destinationDir: string, excludedFolders: string[]): Promise<void>;
+export declare function copyRecursive(source: string, destination: string, excludedFolders: string[]): Promise<void>;
+export declare function removeFolderSync(folderPath: string): void;

package/dist/util.js

@@ -22,9 +22,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isFolderExists = void 0;
+exports.removeFolderSync = exports.copyRecursive = exports.copyFilesWithExclusion = exports.copyFileSync = exports.copyFolderSync = exports.isFolderExists = void 0;
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 function isFolderExists(folderPath) {
     try {
         // Check if the path exists
@@ -39,3 +49,93 @@ function isFolderExists(folderPath) {
     }
 }
 exports.isFolderExists = isFolderExists;
+function copyFolderSync(source, destination) {
+    if (!fs.existsSync(destination)) {
+        fs.mkdirSync(destination);
+    }
+    const files = fs.readdirSync(source);
+    for (const file of files) {
+        const currentPath = path.join(source, file);
+        const destinationPath = path.join(destination, file);
+        if (fs.statSync(currentPath).isDirectory()) {
+            copyFolderSync(currentPath, destinationPath);
+        }
+        else {
+            fs.copyFileSync(currentPath, destinationPath);
+        }
+    }
+}
+exports.copyFolderSync = copyFolderSync;
+function copyFileSync(source, target) {
+    let targetFile = target;
+    // If target is a directory, a new file with the same name will be created
+    if (fs.existsSync(target)) {
+        if (fs.lstatSync(target).isDirectory()) {
+            targetFile = path.join(target, path.basename(source));
+        }
+    }
+    fs.writeFileSync(targetFile, fs.readFileSync(source));
+}
+exports.copyFileSync = copyFileSync;
+function copyFilesWithExclusion(sourceDir, destinationDir, excludedFolders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            // Ensure the destination directory exists
+            yield fs.promises.mkdir(destinationDir, { recursive: true });
+            // Start copying recursively from the source directory
+            yield copyRecursive(sourceDir, destinationDir, excludedFolders);
+        }
+        catch (error) {
+            console.error('An error occurred during copying files:', error);
+        }
+    });
+}
+exports.copyFilesWithExclusion = copyFilesWithExclusion;
+// Function to recursively copy files and directories
+function copyRecursive(source, destination, excludedFolders) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // Get a list of all files and directories in the source directory
+        const files = yield fs.promises.readdir(source);
+        // Iterate through each file or directory
+        for (const file of files) {
+            const sourcePath = path.join(source, file);
+            const destPath = path.join(destination, file);
+            // Get the file's stats
+            const stats = yield fs.promises.stat(sourcePath);
+            // If it's a directory, recursively copy it (unless it's excluded)
+            if (stats.isDirectory()) {
+                if (excludedFolders.includes(file)) {
+                    // Skipping directory: ${sourcePath}
+                }
+                else {
+                    // Ensure destination directory exists before copying
+                    yield fs.promises.mkdir(destPath, { recursive: true });
+                    yield copyRecursive(sourcePath, destPath, excludedFolders);
+                }
+            }
+            else {
+                // Otherwise, copy the file
+                yield fs.promises.copyFile(sourcePath, destPath);
+            }
+        }
+    });
+}
+exports.copyRecursive = copyRecursive;
+function removeFolderSync(folderPath) {
+    if (fs.existsSync(folderPath)) {
+        fs.readdirSync(folderPath).forEach((file) => {
+            const curPath = path.join(folderPath, file);
+            if (fs.lstatSync(curPath).isDirectory()) {
+                // Recursive call for directories
+                removeFolderSync(curPath);
+            }
+            else {
+                // Delete files
+                fs.unlinkSync(curPath);
+            }
+        });
+        // Remove the directory itself
+        fs.rmdirSync(folderPath);
+    }
+}
+exports.removeFolderSync = removeFolderSync;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@offckb/cli",
-  "version": "0.1.0-rc3",
-  "description": "ckb development environment for professionals",
+  "version": "0.1.0-rc5",
+  "description": "ckb development network for your first try",
   "author": "Retric Su <retric@cryptape.com>",
   "license": "MIT",
   "repository": {
@@ -15,8 +15,8 @@
   "files": [
     "dist",
     "account",
-    "docker",
-    "template"
+    "ckb",
+    "templates"
   ],
   "private": false,
   "publishConfig": {
@@ -26,10 +26,9 @@
     "build": "tsc",
     "start": "ts-node-dev --transpile-only src/cli.ts",
     "clean": "rm -rf ./target",
-    "docker": "cd docker && docker-compose up",
-    "lint": "eslint \"{src,template}/**/*.ts\" \"{src,template}/**/*.tsx\" --ignore-pattern 'node_modules/'",
-    "lint:fix": "eslint \"{src,template}/**/*.ts\" \"{src,template}/**/*.tsx\" --ignore-pattern 'node_modules/' --fix",
-    "fmt": "prettier --write '{src,template,account}/**/*.{js,jsx,ts,tsx,md,json}'"
+    "lint": "eslint \"{src,templates}/**/*.ts\" \"{src,templates}/**/*.tsx\" --ignore-pattern 'node_modules/'",
+    "lint:fix": "eslint \"{src,templates}/**/*.ts\" \"{src,templates}/**/*.tsx\" --ignore-pattern 'node_modules/' --fix",
+    "fmt": "prettier --write '{src,templates,account}/**/*.{js,jsx,ts,tsx,md,json}'"
   },
   "husky": {
     "hooks": {
@@ -37,7 +36,7 @@
     }
   },
   "lint-staged": {
-    "{src,template,account}/**/*.{js,jsx,ts,tsx,md,json}": "prettier --ignore-unknown --write"
+    "{src,templates,account}/**/*.{js,jsx,ts,tsx,md,json}": "prettier --ignore-unknown --write"
   },
   "eslintConfig": {
     "extends": [
@@ -60,6 +59,7 @@
   },
   "dependencies": {
     "@ckb-lumos/lumos": "0.21.1",
+    "@inquirer/prompts": "^4.1.0",
     "adm-zip": "^0.5.10",
     "axios": "^1.6.7",
     "child_process": "^1.0.2",

package/{template → templates}/config.json

@@ -4,7 +4,7 @@
     "SECP256K1_BLAKE160": {
       "CODE_HASH": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x37f2b7799b199491f4732c572c086afdace0bf92992faf0b90bae44cdd119f9e",
+      "TX_HASH": "0x75be96e1871693f030db27ddae47890a28ab180e88e36ebb3575d9f1377d3da7",
       "INDEX": "0x0",
       "DEP_TYPE": "depGroup",
       "SHORT_ID": 1
@@ -12,14 +12,14 @@
     "SECP256K1_BLAKE160_MULTISIG": {
       "CODE_HASH": "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x37f2b7799b199491f4732c572c086afdace0bf92992faf0b90bae44cdd119f9e",
+      "TX_HASH": "0x75be96e1871693f030db27ddae47890a28ab180e88e36ebb3575d9f1377d3da7",
       "INDEX": "0x1",
       "DEP_TYPE": "depGroup"
     },
     "DAO": {
       "CODE_HASH": "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x2",
       "DEP_TYPE": "code",
       "SHORT_ID": 2
@@ -27,35 +27,35 @@
     "SUDT": {
       "CODE_HASH": "0x6283a479a3cf5d4276cd93594de9f1827ab9b55c7b05b3d28e4c2e0a696cfefd",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x5",
       "DEP_TYPE": "code"
     },
     "XUDT": {
       "CODE_HASH": "0x1a1e4fef34f5982906f745b048fe7b1089647e82346074e0f32c2ece26cf6b1e",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x6",
       "DEP_TYPE": "code"
     },
     "OMNILOCK": {
       "CODE_HASH": "0x9c6933d977360f115a3e9cd5a2e0e475853681b80d775d93ad0f8969da343e56",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x7",
       "DEP_TYPE": "code"
     },
     "ANYONE_CAN_PAY": {
       "CODE_HASH": "0xe09352af0066f3162287763ce4ddba9af6bfaeab198dc7ab37f8c71c9e68bb5b",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x8",
       "DEP_TYPE": "code"
     },
     "ALWAYS_SUCCESS": {
       "CODE_HASH": "0xbb4469004225b39e983929db71fe2253cba1d49a76223e9e1d212cdca1f79f28",
       "HASH_TYPE": "type",
-      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "TX_HASH": "0x1dbed8dcfe0f18359c65c5e9546fd15cd69de73ea0a502345be30180649c9467",
       "INDEX": "0x9",
       "DEP_TYPE": "code"
     }

package/templates/transfer/index.html

@@ -0,0 +1,13 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>View and Transfer Balance</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="index.tsx" type="module"></script>
+  </body>
+</html>

package/{template → templates/transfer}/index.tsx

@@ -29,10 +29,35 @@ export function App() {
     }
   }, [privKey]);
 
+  const onInputPrivKey = (e: React.ChangeEvent<HTMLInputElement>) => {
+    // Regular expression to match a valid private key with "0x" prefix
+    const priv = e.target.value;
+    const privateKeyRegex = /^0x[0-9a-fA-F]{64}$/;
+
+    const isValid = privateKeyRegex.test(priv);
+    if (isValid) {
+      setPrivKey(priv);
+    } else {
+      alert(
+        `Invalid private key: must start with 0x and 32 bytes length. Ensure you're using a valid private key from the offckb accounts list.`,
+      );
+    }
+  };
+
+  const enabled = +amount > 6100000000 && +balance > +amount && toAddr.length > 0;
+  const amountTip =
+    amount.length > 0 && +amount < 6100000000 ? (
+      <span>
+        amount must larger than 6,100,000,000(61 CKB), see{' '}
+        <a href="https://medium.com/nervosnetwork/understanding-the-nervos-dao-and-cell-model-d68f38272c24">why</a>
+      </span>
+    ) : null;
+
   return (
     <div>
+      <h1>View and Transfer Balance</h1>
       <label htmlFor="private-key">Private Key: </label>&nbsp;
-      <input id="private-key" type="text" onChange={(e) => setPrivKey(e.target.value)} />
+      <input id="private-key" type="text" onChange={onInputPrivKey} />
       <ul>
         <li>CKB Address: {fromAddr}</li>
         <li>
@@ -40,16 +65,25 @@ export function App() {
           <pre>{JSON.stringify(fromLock, null, 2)}</pre>
         </li>
 
-        <li>Total capacity: {balance}</li>
+        <li>Total capacity: {(+balance).toLocaleString()}</li>
       </ul>
       <label htmlFor="to-address">Transfer to Address: </label>&nbsp;
       <input id="to-address" type="text" onChange={(e) => setToAddr(e.target.value)} />
       <br />
       <label htmlFor="amount">Amount</label>
       &nbsp;
-      <input id="amount" type="text" onChange={(e) => setAmount(e.target.value)} />
+      <input id="amount" type="number" onChange={(e) => setAmount(e.target.value)} />
+      <small>Tx fee: 100,000 (0.001 CKB)</small>
+      <br />
+      <small style={{ color: 'red' }}>{amountTip}</small>
+      <br />
       <br />
-      <button onClick={() => transfer({ amount, from: fromAddr, to: toAddr, privKey }).catch(alert)}>Transfer</button>
+      <button
+        disabled={!enabled}
+        onClick={() => transfer({ amount, from: fromAddr, to: toAddr, privKey }).catch(alert)}
+      >
+        Transfer
+      </button>
     </div>
   );
 }

package/{template → templates/xudt}/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta http-equiv="X-UA-Compatible" content="IE=edge" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>happy coding with offckb</title>
+    <title>Issue Custom Token</title>
   </head>
   <body>
     <div id="root"></div>

package/templates/xudt/index.tsx

@@ -0,0 +1,106 @@
+import React, { useEffect, useState } from 'react';
+import ReactDOM from 'react-dom';
+import { Cell, Script } from '@ckb-lumos/lumos';
+import {
+  capacityOf,
+  computeLockScriptHashFromPrivateKey,
+  generateAccountFromPrivateKey,
+  issueToken,
+  queryIssuedTokenCells,
+  readTokenAmount,
+} from './lib';
+
+const app = document.getElementById('root');
+ReactDOM.render(<App />, app);
+
+export function App() {
+  const [privKey, setPrivKey] = useState('');
+  const [fromAddr, setFromAddr] = useState('');
+  const [fromLock, setFromLock] = useState<Script>();
+  const [balance, setBalance] = useState('0');
+
+  const [amount, setAmount] = useState('');
+  const [cells, setCells] = useState<Cell[]>([]);
+
+  useEffect(() => {
+    const updateFromInfo = async () => {
+      const { lockScript, address } = generateAccountFromPrivateKey(privKey);
+      const capacity = await capacityOf(address);
+      setFromAddr(address);
+      setFromLock(lockScript);
+      setBalance(capacity.toString());
+    };
+
+    if (privKey) {
+      updateFromInfo();
+    }
+  }, [privKey]);
+
+  const onInputPrivKey = (e: React.ChangeEvent<HTMLInputElement>) => {
+    // Regular expression to match a valid private key with "0x" prefix
+    const priv = e.target.value;
+    const privateKeyRegex = /^0x[0-9a-fA-F]{64}$/;
+
+    const isValid = privateKeyRegex.test(priv);
+    if (isValid) {
+      setPrivKey(priv);
+    } else {
+      alert(
+        `Invalid private key: must start with 0x and 32 bytes length. Ensure you're using a valid private key from the offckb accounts list.`,
+      );
+    }
+  };
+
+  const enabledIssue = +amount > 0 && +balance > 6100000000;
+  const enabledCheck = privKey.length > 0;
+  return (
+    <div>
+      <h1>
+        Issue Custom Token{' '}
+        <small>
+          <a href="https://github.com/XuJiandong/rfcs/blob/xudt/rfcs/0052-extensible-udt/0052-extensible-udt.md#xudt-witness">
+            {'(xUDT specs)'}
+          </a>
+        </small>
+      </h1>
+      <p></p>
+      <label htmlFor="private-key">Private Key: </label>&nbsp;
+      <input id="private-key" type="text" onChange={onInputPrivKey} />
+      <ul>
+        <li>CKB Address: {fromAddr}</li>
+        <li>
+          Current lock script:
+          <pre>{JSON.stringify(fromLock, null, 2)}</pre>
+        </li>
+
+        <li>Total capacity: {(+balance).toLocaleString()}</li>
+      </ul>
+      <br />
+      <label htmlFor="amount">Token Amount</label>
+      &nbsp;
+      <input id="amount" type="text" onChange={(e) => setAmount(e.target.value)} />
+      <br />
+      <button disabled={!enabledIssue} onClick={() => issueToken(privKey, amount).catch(alert)}>
+        Issue token
+      </button>
+      <br />
+      <br />
+      <hr />
+      <p>after issued token, click the below button to check it</p>
+      <button disabled={!enabledCheck} onClick={() => queryIssuedTokenCells(privKey).then(setCells).catch(alert)}>
+        Check issued token
+      </button>
+      {cells.length > 0 && <h3>Result: all the cells which hosted this issued token</h3>}
+      {cells.map((cell, index) => (
+        <div key={index}>
+          <p>Cell #{index}</p>
+          <p>token amount: {readTokenAmount(cell.data).toNumber()}</p>
+          <p>issuer lockScript Hash: {computeLockScriptHashFromPrivateKey(privKey)}</p>
+          <p>token xudt args: {cell.cellOutput.type.args}</p>
+          <p>token holder's lockScript args: {cell.cellOutput.lock.args}</p>
+          <hr />
+        </div>
+      ))}
+    </div>
+  );
+}

package/templates/xudt/lib.ts

@@ -0,0 +1,179 @@
+import { helpers, Address, Script, hd, config, Cell, commons, BI, utils, CellDep } from '@ckb-lumos/lumos';
+import { values, blockchain } from '@ckb-lumos/base';
+import { indexer, lumosConfig, rpc } from './ckb';
+import { TransactionSkeletonType } from '@ckb-lumos/helpers';
+import { bytes, number } from '@ckb-lumos/codec';
+import { xudtWitnessType } from './scheme';
+
+config.initializeConfig(lumosConfig);
+
+type Account = {
+  lockScript: Script;
+  address: Address;
+  pubKey: string;
+};
+export const generateAccountFromPrivateKey = (privKey: string): Account => {
+  const pubKey = hd.key.privateToPublic(privKey);
+  const args = hd.key.publicKeyToBlake160(pubKey);
+  const template = lumosConfig.SCRIPTS['SECP256K1_BLAKE160']!;
+  const lockScript = {
+    codeHash: template.CODE_HASH,
+    hashType: template.HASH_TYPE,
+    args: args,
+  };
+  const address = helpers.encodeToAddress(lockScript, { config: lumosConfig });
+  return {
+    lockScript,
+    address,
+    pubKey,
+  };
+};
+
+export const computeLockScriptHashFromPrivateKey = (privkey: string) => {
+  const { lockScript } = generateAccountFromPrivateKey(privkey);
+  return utils.computeScriptHash(lockScript);
+};
+
+export async function capacityOf(address: string): Promise<BI> {
+  const collector = indexer.collector({
+    lock: helpers.parseAddress(address, { config: lumosConfig }),
+  });
+
+  let balance = BI.from(0);
+  for await (const cell of collector.collect()) {
+    balance = balance.add(cell.cellOutput.capacity);
+  }
+
+  return balance;
+}
+
+export function addCellDep(txSkeleton: TransactionSkeletonType, newCellDep: CellDep): TransactionSkeletonType {
+  const cellDep = txSkeleton.get('cellDeps').find((cellDep) => {
+    return (
+      cellDep.depType === newCellDep.depType &&
+      new values.OutPointValue(cellDep.outPoint, { validate: false }).equals(
+        new values.OutPointValue(newCellDep.outPoint, { validate: false }),
+      )
+    );
+  });
+
+  if (!cellDep) {
+    txSkeleton = txSkeleton.update('cellDeps', (cellDeps) => {
+      return cellDeps.push({
+        outPoint: newCellDep.outPoint,
+        depType: newCellDep.depType,
+      });
+    });
+  }
+
+  return txSkeleton;
+}
+
+export async function issueToken(privKey: string, amount: string) {
+  const { lockScript } = generateAccountFromPrivateKey(privKey);
+  const xudtDeps = lumosConfig.SCRIPTS.XUDT;
+  const lockDeps = lumosConfig.SCRIPTS.SECP256K1_BLAKE160;
+
+  const xudtArgs = utils.computeScriptHash(lockScript) + '00000000';
+  const typeScript = {
+    codeHash: xudtDeps.CODE_HASH,
+    hashType: xudtDeps.HASH_TYPE,
+    args: xudtArgs,
+  };
+
+  let txSkeleton = helpers.TransactionSkeleton();
+  txSkeleton = addCellDep(txSkeleton, {
+    outPoint: {
+      txHash: lockDeps.TX_HASH,
+      index: lockDeps.INDEX,
+    },
+    depType: lockDeps.DEP_TYPE,
+  });
+  txSkeleton = addCellDep(txSkeleton, {
+    outPoint: {
+      txHash: xudtDeps.TX_HASH,
+      index: xudtDeps.INDEX,
+    },
+    depType: xudtDeps.DEP_TYPE,
+  });
+
+  const targetOutput: Cell = {
+    cellOutput: {
+      capacity: '0x0',
+      lock: lockScript,
+      type: typeScript,
+    },
+    data: bytes.hexify(number.Uint128LE.pack(amount)),
+  };
+
+  // additional 0.001 ckb for tx fee
+  // the tx fee could calculated by tx size
+  // this is just a simple example
+  const capacity = helpers.minimalCellCapacity(targetOutput);
+  targetOutput.cellOutput.capacity = '0x' + capacity.toString(16);
+  const neededCapacity = BI.from(capacity.toString(10)).add(100000);
+  let collectedSum = BI.from(0);
+  const collected: Cell[] = [];
+  const collector = indexer.collector({ lock: lockScript, type: 'empty' });
+  for await (const cell of collector.collect()) {
+    collectedSum = collectedSum.add(cell.cellOutput.capacity);
+    collected.push(cell);
+    if (collectedSum >= neededCapacity) break;
+  }
+
+  if (collectedSum.lt(neededCapacity)) {
+    throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
+  }
+
+  const changeOutput: Cell = {
+    cellOutput: {
+      capacity: collectedSum.sub(neededCapacity).toHexString(),
+      lock: lockScript,
+    },
+    data: '0x',
+  };
+
+  txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...collected));
+  txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(targetOutput, changeOutput));
+  /* 65-byte zeros in hex */
+  const lockWitness =
+    '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000';
+  const outputTypeWitness = xudtWitnessType.pack({ extension_data: [] });
+  const witnessArgs = blockchain.WitnessArgs.pack({ lock: lockWitness, outputType: outputTypeWitness });
+  const witness = bytes.hexify(witnessArgs);
+  txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(0, witness));
+
+  // signing
+  txSkeleton = commons.common.prepareSigningEntries(txSkeleton);
+  const message = txSkeleton.get('signingEntries').get(0)?.message;
+  const Sig = hd.key.signRecoverable(message!, privKey);
+  const tx = helpers.sealTransaction(txSkeleton, [Sig]);
+  console.log(tx);
+
+  const hash = await rpc.sendTransaction(tx, 'passthrough');
+  console.log('The transaction hash is', hash);
+  alert(`The transaction hash is ${hash}`);
+}
+
+export async function queryIssuedTokenCells(privKey: string) {
+  const { lockScript } = generateAccountFromPrivateKey(privKey);
+  const xudtDeps = lumosConfig.SCRIPTS.XUDT;
+
+  const xudtArgs = utils.computeScriptHash(lockScript) + '00000000';
+  const typeScript = {
+    codeHash: xudtDeps.CODE_HASH,
+    hashType: xudtDeps.HASH_TYPE,
+    args: xudtArgs,
+  };
+
+  const collected: Cell[] = [];
+  const collector = indexer.collector({ type: typeScript });
+  for await (const cell of collector.collect()) {
+    collected.push(cell);
+  }
+  return collected;
+}
+
+export function readTokenAmount(amount: string) {
+  return number.Uint128LE.unpack(amount);
+}

package/templates/xudt/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@offckb/xudt",
+  "version": "0.1.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "parcel index.html",
+    "lint": "tsc --noEmit"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@ckb-lumos/base": "0.21.1",
+    "@ckb-lumos/codec": "0.21.1",
+    "@ckb-lumos/lumos": "0.21.1",
+    "@types/react": "^18.0.25",
+    "@types/react-dom": "^18.0.9",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "crypto-browserify": "^3.12.0",
+    "parcel": "^2.9.3",
+    "path-browserify": "^1.0.0",
+    "process": "^0.11.10",
+    "stream-browserify": "^3.0.0"
+  }
+}