@offckb/cli 0.1.0-rc4 → 0.1.0-rc6

package/README.md

@@ -1,6 +1,35 @@
 ## OffCKB
 
-CKB local development environment for your first try
+[![npm](https://img.shields.io/npm/v/@offckb/cli.svg?maxAge=1000)](https://www.npmjs.com/package/@offckb/cli)
+[![CI](https://github.com/retricsu/offckb/actions/workflows/node.js.yml/badge.svg)](https://github.com/retricsu/offckb/actions/workflows/node.js.yml)
+[![npm](https://img.shields.io/npm/dt/@offckb/cli.svg?maxAge=1000)](https://www.npmjs.com/package/@offckb/cli)
+[![npm](https://img.shields.io/npm/l/@offckb/cli.svg?maxAge=1000)](https://github.com/jeffijoe/@offckb/cli/blob/master/LICENSE.md)
+[![node](https://img.shields.io/node/v/@offckb/cli.svg?maxAge=1000)](https://www.npmjs.com/package/@offckb/cli)
+
+**CKB local development network for your first try.**
+
+- One-line command to start a devnet
+- no docker required
+- pre-funded test accounts
+- packed with the most useful scripts like Omnilock and Spore-contract
+- multiple minimal Dapp templates to learn and get your hands dirty
+
+Start building on Nervos blockchain, right now, right away!
+
+## Table of Contents
+
+- [OffCKB](#offckb)
+- [Table of Contents](#table-of-contents)
+- [Install](#install)
+- [Usage](#usage)
+- [Get started](#get-started)
+  - [Step 1: Create A Project](#step-1-create-a-project)
+  - [Step 2: Start the Devnet](#step-2-start-the-devnet)
+  - [Step 3: Access Pre-funded Accounts](#step-3-access-pre-funded-accounts)
+- [Built-in scripts](#built-in-scripts)
+- [Accounts](#accounts)
+- [About Lumos](#about-lumos)
+- [Contributing](#contributing)
 
 ## Install
 
@@ -20,7 +49,9 @@ offckb accounts # list 20 accounts info with prefund CKB tokens
 offckb list-hashes # list built-in scripts hashes, equals `ckb list-hashes`
 ```
 
-### Get started
+## Get started
+
+### Step 1: Create A Project
 
 ```sh
 offckb init my-awesome-ckb-dapp
@@ -44,21 +75,53 @@ Server running at http://localhost:1234
 ✨ Built in 10ms
 ```
 
-open another terminal and start the devnet:
+### Step 2: Start the Devnet
+
+Open another terminal and run:
 
 ```sh
 offckb node
+
+# result
+# ...
+CKB-Miner: 2024-03-04 14:35:12.563 +00:00 client INFO ckb_miner::miner  Found! #3181 0x3749481a320824fe21077eaa8ec9d024a7b62d031720c27c1ef1681e8ab349e8
+
+CKB-Miner: 2024-03-04 14:35:17.567 +00:00 client INFO ckb_miner::miner  Found! #3184 0xa612a9ea35f292a6473e23e88856283aea8b1bc6a607147bef5c06c94e964f2f
+#...
 ```
 
-open another terminal and check the accounts to use:
+You can leave this terminal open to keep the devnet running, feel free to `ctrl+c` to exit the terminal and stop the local blockchain.
+
+### Step 3: Access Pre-funded Accounts
+
+Open another terminal and check the accounts to use:
 
 ```sh
 offckb accounts
+
+# result
+Print account list, each account is funded with 42_000_000_00000000 capacity in the genesis block.
+[
+  {
+    privkey: '0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6',
+    pubkey: '0x02025fa7b61b2365aa459807b84df065f1949d58c0ae590ff22dd2595157bffefa',
+    lockScript: {
+      codeHash: '0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8',
+      hashType: 'type',
+      args: '0x8e42b1999f265a0078503c4acec4d5e134534297'
+    },
+    address: 'ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8',
+    args: '0x8e42b1999f265a0078503c4acec4d5e134534297'
+  },
+  {
+    privkey: '0x9f315d5a9618a39fdc487c7a67a8581d40b045bd7a42d83648ca80ef3b2cb4a1',
+    pubkey: '0x026efa0579f09cc7c1129b78544f70098c90b2ab155c10746316f945829c034a2d',
+    lockScript: {
 ```
 
 Copy some private keys and visit http://localhost:1234 to play your first CKB Dapp!
 
-### Built-in scripts
+## Built-in scripts
 
 - [x] xUDT https://github.com/nervosnetwork/rfcs/pull/428
   - commit id: 410b16c
@@ -67,21 +130,23 @@ Copy some private keys and visit http://localhost:1234 to play your first CKB Da
 - [x] AnyoneCanPay https://github.com/cryptape/anyone-can-pay
   - commit id: b845b3b
 - [x] AlwaysSuccess https://github.com/nervosnetwork/ckb-production-scripts/blob/master/c/always_success.c
-  - commit id: 410b16c 
-- [ ] Spore https://github.com/sporeprotocol/spore-contract
+  - commit id: 410b16c
+- [x] Spore https://github.com/sporeprotocol/spore-contract
+  - version: 0.2.2-beta.1
 
-### Accounts
+## Accounts
 
 `offckb` comes with 20 accounts, each account is funded with 42_000_000_00000000 capacity in the genesis block.
 
 all the private keys are recorded in the `account/keys` file.
 detail informations about each account are recorded in the `account/account.json` file.
 
+:warning: **DO NOT SEND REAL ASSETS INTO ALL THESE ACCOUNTS, YOU CAN LOOSE YOUR MONEY** :warning:
 
 ## About Lumos
 
 `offckb` uses [Lumos](https://github.com/ckb-js/lumos) as the CKB Dapp framework to build the template projects.
 
-## Development
+## Contributing
 
 check [development doc](/docs/develop.md)

package/ckb/devnet/specs/dev.toml

@@ -49,7 +49,21 @@ create_type_id = true
 [[genesis.system_cells]]
 file = { file = "always_success" }
 create_type_id = true
-
+[[genesis.system_cells]]
+file = { file = "spore-scripts/spore" }
+create_type_id = false
+[[genesis.system_cells]]
+file = { file = "spore-scripts/cluster" }
+create_type_id = false
+[[genesis.system_cells]]
+file = { file = "spore-scripts/cluster_agent" }
+create_type_id = false
+[[genesis.system_cells]]
+file = { file = "spore-scripts/cluster_proxy" }
+create_type_id = false
+[[genesis.system_cells]]
+file = { file = "spore-scripts/spore_extension_lua" }
+create_type_id = false
 
 [genesis.system_cells_lock]
 code_hash = "0x0000000000000000000000000000000000000000000000000000000000000000"

package/dist/cfg/select.js

@@ -21,21 +21,20 @@ function selectTemplate() {
             message: 'Select a dapp template',
             choices: [
                 {
-                    name: 'Transfer CKB',
+                    name: 'View and Transfer Balance',
                     value: 'transfer',
-                    description: 'a simple dapp to check CKB balance and transfer CKB from address to address',
+                    description: 'a simple dapp to check CKB balance and transfer CKB',
                 },
-                new prompts_1.Separator(),
                 {
-                    name: 'Issue Token With XUDT scripts(coming)',
+                    name: 'Issue Token via XUDT scripts',
                     value: 'xudt',
-                    description: 'a simple dapp to issue your own token with XUDT scripts(coming)',
-                    disabled: true,
+                    description: 'a simple dapp to issue your own token via XUDT scripts',
                 },
+                new prompts_1.Separator(),
                 {
-                    name: 'Issue Token With Max Supply via Omnilock And XUDT scripts(coming)',
+                    name: 'Issue Token With Max Supply Limit via Omnilock And XUDT scripts(coming)',
                     value: 'xudt',
-                    description: 'a simple dapp to issue your own token with XUDT scripts',
+                    description: 'a simple dapp to issue your own token with max supply limit via XUDT scripts',
                     disabled: true,
                 },
                 {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@offckb/cli",
-  "version": "0.1.0-rc4",
-  "description": "ckb development environment for professionals",
+  "version": "0.1.0-rc6",
+  "description": "ckb development network for your first try",
   "author": "Retric Su <retric@cryptape.com>",
   "license": "MIT",
   "repository": {

package/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

@@ -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>Transfer CKB</title>
+    <title>View and Transfer Balance</title>
   </head>
   <body>
     <div id="root"></div>

package/templates/transfer/index.tsx

@@ -55,7 +55,7 @@ export function App() {
 
   return (
     <div>
-      <h1>Transfer CKB between addresses</h1>
+      <h1>View and Transfer Balance</h1>
       <label htmlFor="private-key">Private Key: </label>&nbsp;
       <input id="private-key" type="text" onChange={onInputPrivKey} />
       <ul>

package/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

@@ -1,26 +1,25 @@
 import React, { useEffect, useState } from 'react';
 import ReactDOM from 'react-dom';
-import { Script } from '@ckb-lumos/lumos';
-import { capacityOf, generateAccountFromPrivateKey, transfer } from './lib';
+import { Cell, Script, Transaction, utils } from '@ckb-lumos/lumos';
+import { issueToken, queryIssuedTokenCells, transferTokenToAddress } from './lib';
+import { capacityOf, generateAccountFromPrivateKey, readTokenAmount } from './util';
 
 const app = document.getElementById('root');
 ReactDOM.render(<App />, app);
 
-export function App() {
+function IssuedToken() {
   const [privKey, setPrivKey] = useState('');
-  const [fromAddr, setFromAddr] = useState('');
-  const [fromLock, setFromLock] = useState<Script>();
+  const [lockScript, setLockScript] = useState<Script>();
   const [balance, setBalance] = useState('0');
-
-  const [toAddr, setToAddr] = useState('');
   const [amount, setAmount] = useState('');
+  const [issuedTokenCell, setIssuedTokenCell] = useState<Cell>();
+  const [txHash, setTxHash] = useState<string>();
 
   useEffect(() => {
     const updateFromInfo = async () => {
       const { lockScript, address } = generateAccountFromPrivateKey(privKey);
       const capacity = await capacityOf(address);
-      setFromAddr(address);
-      setFromLock(lockScript);
+      setLockScript(lockScript);
       setBalance(capacity.toString());
     };
 
@@ -29,27 +28,185 @@ export function App() {
     }
   }, [privKey]);
 
+  const onInputPrivKey = (e: React.ChangeEvent<HTMLInputElement>) => {
+    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;
+
   return (
-    <div>
+    <>
+      <h2>Issue Custom Token</h2>
+      <p></p>
       <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>Balance(Total Capacity): {(+balance).toLocaleString()}</li>
         <li>
-          Current lock script:
-          <pre>{JSON.stringify(fromLock, null, 2)}</pre>
+          Lock Script:
+          <pre>{JSON.stringify(lockScript, null, 2)}</pre>
         </li>
-
-        <li>Total capacity: {balance}</li>
+        <li>Lock Script Hash: {lockScript && utils.computeScriptHash(lockScript)}</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>
+      <label htmlFor="amount">Token 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)} />
       <br />
-      <button onClick={() => transfer({ amount, from: fromAddr, to: toAddr, privKey }).catch(alert)}>Transfer</button>
+      <button
+        disabled={!enabledIssue}
+        onClick={() =>
+          issueToken(privKey, amount)
+            .then((result) => {
+              setIssuedTokenCell(result.targetOutput);
+              setTxHash(result.hash);
+            })
+            .catch(alert)
+        }
+      >
+        Issue Token
+      </button>
+      <div>
+        {txHash && issuedTokenCell && (
+          <>
+            <h4>Result</h4>
+            <li>Transaction hash: {txHash}</li>
+            <li>
+              Token xUDT args: {issuedTokenCell.cellOutput.type.args}{' '}
+              <strong>
+                {
+                  '(Noticed that the xUDT args works like the unique id for your issued token, Think of it like an ERC20 contract address)'
+                }
+              </strong>
+            </li>
+            <li>
+              Token cell: <pre>{JSON.stringify(issuedTokenCell, null, 2)}</pre>
+            </li>
+          </>
+        )}
+      </div>
+    </>
+  );
+}
+
+function ViewIssuedToken() {
+  const [xudtArgs, setXudtArgs] = useState<string>();
+  const [cells, setCells] = useState<Cell[]>([]);
+  return (
+    <>
+      <h2>View Custom Token</h2>
+      <div>
+        <label htmlFor="xudt-args">xDUT args: </label>&nbsp;
+        <input id="xudt-args" type="text" onChange={(e) => setXudtArgs(e.target.value)} />
+      </div>
+
+      <button disabled={!xudtArgs} onClick={() => queryIssuedTokenCells(xudtArgs).then(setCells).catch(alert)}>
+        Query 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>
+          <li>Token amount: {readTokenAmount(cell.data).toNumber()}</li>
+          <li>Token xUDT args: {cell.cellOutput.type.args}</li>
+          <li>Token holder's lock script args: {cell.cellOutput.lock.args}</li>
+          <hr />
+        </div>
+      ))}
+    </>
+  );
+}
+
+function TransferIssuedToken() {
+  const [udtArgs, setUdtArgs] = useState<string>('');
+  const [senderPrivkey, setSenderPrivkey] = useState<string>('');
+  const [transferAmount, setTransferAmount] = useState('');
+  const [receiverAddress, setReceiverAddress] = useState('');
+  const [tx, setTx] = useState<Transaction>();
+
+  const onInputSenderPrivKey = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const priv = e.target.value;
+    const privateKeyRegex = /^0x[0-9a-fA-F]{64}$/;
+    const isValid = privateKeyRegex.test(priv);
+    if (isValid) {
+      setSenderPrivkey(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 enabledCheck =
+    senderPrivkey.length > 0 && udtArgs.length > 0 && transferAmount.length > 0 && receiverAddress.length > 0;
+
+  return (
+    <>
+      <h2>Transfer Custom Token</h2>
+      <label htmlFor="sender-private-key">Private Key: </label>&nbsp;
+      <input id="sender-private-key" type="text" onChange={onInputSenderPrivKey} />
+      <br />
+      <label htmlFor="udt">xUDT args: </label>
+      &nbsp;
+      <input id="udt" type="text" onChange={(e) => setUdtArgs(e.target.value)} />
+      <br />
+      <label htmlFor="transferAmount">Transfer Token Amount: </label>
+      &nbsp;
+      <input id="transferAmount" type="number" onChange={(e) => setTransferAmount(e.target.value)} />
+      <br />
+      <label htmlFor="receiverAddress">Receiver Address: </label>
+      &nbsp;
+      <input id="receiverAddress" type="text" onChange={(e) => setReceiverAddress(e.target.value)} />
+      <br />
+      <button
+        disabled={!enabledCheck}
+        onClick={() =>
+          transferTokenToAddress(udtArgs, senderPrivkey, transferAmount, receiverAddress)
+            .then((res) => setTx(res.tx))
+            .catch(alert)
+        }
+      >
+        Transfer Custom Token
+      </button>
+      <div>
+        {tx && (
+          <>
+            <h4>Result</h4>
+            <li>
+              Transaction: <pre>{JSON.stringify(tx, null, 2)}</pre>
+            </li>
+          </>
+        )}
+      </div>
+    </>
+  );
+}
+
+export function App() {
+  return (
+    <div>
+      <h1>
+        xUDT Scripts Dapp Example &nbsp;
+        <small>
+          <a href="https://github.com/XuJiandong/rfcs/blob/xudt/rfcs/0052-extensible-udt/0052-extensible-udt.md#xudt-witness">
+            {'(see xUDT specs)'}
+          </a>
+        </small>
+      </h1>
+      <IssuedToken />
+      <hr />
+      <ViewIssuedToken />
+      <hr />
+      <TransferIssuedToken />
     </div>
   );
 }

package/templates/xudt/lib.ts

@@ -1,73 +1,58 @@
-import { bytes } from '@ckb-lumos/codec';
-import { helpers, Address, Script, hd, config, Cell, commons, WitnessArgs, BI } from '@ckb-lumos/lumos';
-import { values, blockchain } from '@ckb-lumos/base';
+import { helpers, hd, config, Cell, commons, BI, utils } from '@ckb-lumos/lumos';
+import { blockchain, HexString } from '@ckb-lumos/base';
 import { indexer, lumosConfig, rpc } from './ckb';
-const { ScriptValue } = values;
+import { bytes, number } from '@ckb-lumos/codec';
+import { xudtWitnessType } from './scheme';
+import { addCellDep, generateAccountFromPrivateKey } from './util';
 
 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 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,
   };
-};
 
-export async function capacityOf(address: string): Promise<BI> {
-  const collector = indexer.collector({
-    lock: helpers.parseAddress(address, { config: lumosConfig }),
+  let txSkeleton = helpers.TransactionSkeleton();
+  txSkeleton = addCellDep(txSkeleton, {
+    outPoint: {
+      txHash: lockDeps.TX_HASH,
+      index: lockDeps.INDEX,
+    },
+    depType: lockDeps.DEP_TYPE,
   });
-
-  let balance = BI.from(0);
-  for await (const cell of collector.collect()) {
-    balance = balance.add(cell.cellOutput.capacity);
-  }
-
-  return balance;
-}
-
-interface Options {
-  from: string;
-  to: string;
-  amount: string;
-  privKey: string;
-}
-
-export async function transfer(options: Options): Promise<string> {
-  let txSkeleton = helpers.TransactionSkeleton({});
-  const fromScript = helpers.parseAddress(options.from, {
-    config: lumosConfig,
+  txSkeleton = addCellDep(txSkeleton, {
+    outPoint: {
+      txHash: xudtDeps.TX_HASH,
+      index: xudtDeps.INDEX,
+    },
+    depType: xudtDeps.DEP_TYPE,
   });
-  const toScript = helpers.parseAddress(options.to, { config: lumosConfig });
 
-  if (BI.from(options.amount).lt(BI.from('6100000000'))) {
-    throw new Error(
-      `every cell's capacity must be at least 61 CKB, see https://medium.com/nervosnetwork/understanding-the-nervos-dao-and-cell-model-d68f38272c24`,
-    );
-  }
+  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 neededCapacity = BI.from(options.amount).add(100000);
+  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: fromScript, type: 'empty' });
+  const collector = indexer.collector({ lock: lockScript, type: 'empty' });
   for await (const cell of collector.collect()) {
     collectedSum = collectedSum.add(cell.cellOutput.capacity);
     collected.push(cell);
@@ -78,76 +63,190 @@ export async function transfer(options: Options): Promise<string> {
     throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
   }
 
-  const transferOutput: Cell = {
+  const changeOutput: Cell = {
     cellOutput: {
-      capacity: BI.from(options.amount).toHexString(),
-      lock: toScript,
+      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);
+  return { hash, targetOutput };
+}
+
+export async function queryIssuedTokenCells(xudtArgs: HexString) {
+  const xudtDeps = lumosConfig.SCRIPTS.XUDT;
+  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 async function transferTokenToAddress(
+  udtIssuerArgs: string,
+  senderPrivKey: string,
+  amount: string,
+  receiverAddress: string,
+) {
+  const { lockScript: senderLockScript } = generateAccountFromPrivateKey(senderPrivKey);
+
+  const receiverLockScript = helpers.parseAddress(receiverAddress);
+
+  const xudtDeps = lumosConfig.SCRIPTS.XUDT;
+  const lockDeps = lumosConfig.SCRIPTS.SECP256K1_BLAKE160;
+
+  const xudtArgs = udtIssuerArgs;
+  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: receiverLockScript,
+      type: typeScript,
+    },
+    data: bytes.hexify(number.Uint128LE.pack(amount)),
+  };
+
+  const capacity = helpers.minimalCellCapacity(targetOutput);
+  targetOutput.cellOutput.capacity = '0x' + capacity.toString(16);
+  // additional 0.001 ckb for tx fee
+  // the tx fee could calculated by tx size
+  // this is just a simple example
+  const neededCapacity = BI.from(capacity.toString(10)).add(100000);
+  let collectedSum = BI.from(0);
+  let collectedAmount = BI.from(0);
+  const collected: Cell[] = [];
+  const collector = indexer.collector({ lock: senderLockScript, type: typeScript });
+  for await (const cell of collector.collect()) {
+    collectedSum = collectedSum.add(cell.cellOutput.capacity);
+    collectedAmount = collectedAmount.add(number.Uint128LE.unpack(cell.data));
+    collected.push(cell);
+    if (collectedAmount >= BI.from(amount)) break;
+  }
+
+  let changeOutputTokenAmount = BI.from(0);
+  if (collectedAmount.gt(BI.from(amount))) {
+    changeOutputTokenAmount = collectedAmount.sub(BI.from(amount));
+  }
+
   const changeOutput: Cell = {
     cellOutput: {
-      capacity: collectedSum.sub(neededCapacity).toHexString(),
-      lock: fromScript,
+      capacity: '0x0',
+      lock: senderLockScript,
+      type: typeScript,
     },
-    data: '0x',
+    data: bytes.hexify(number.Uint128LE.pack(changeOutputTokenAmount.toString(10))),
   };
 
-  txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...collected));
-  txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(transferOutput, changeOutput));
-  txSkeleton = txSkeleton.update('cellDeps', (cellDeps) =>
-    cellDeps.push({
-      outPoint: {
-        txHash: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.TX_HASH,
-        index: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.INDEX,
-      },
-      depType: lumosConfig.SCRIPTS.SECP256K1_BLAKE160.DEP_TYPE,
-    }),
-  );
-
-  const firstIndex = txSkeleton
-    .get('inputs')
-    .findIndex((input) =>
-      new ScriptValue(input.cellOutput.lock, { validate: false }).equals(
-        new ScriptValue(fromScript, { validate: false }),
-      ),
-    );
-  if (firstIndex !== -1) {
-    while (firstIndex >= txSkeleton.get('witnesses').size) {
-      txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.push('0x'));
+  const changeOutputNeededCapacity = BI.from(helpers.minimalCellCapacity(changeOutput));
+
+  const extraNeededCapacity = collectedSum.lt(neededCapacity)
+    ? neededCapacity.sub(collectedSum).add(changeOutputNeededCapacity)
+    : collectedSum.sub(neededCapacity).add(changeOutputNeededCapacity);
+
+  if (extraNeededCapacity.gt(0)) {
+    let extraCollectedSum = BI.from(0);
+    const extraCollectedCells: Cell[] = [];
+    const collector = indexer.collector({ lock: senderLockScript, type: 'empty' });
+    for await (const cell of collector.collect()) {
+      extraCollectedSum = extraCollectedSum.add(cell.cellOutput.capacity);
+      extraCollectedCells.push(cell);
+      if (extraCollectedSum >= extraNeededCapacity) break;
     }
-    let witness: string = txSkeleton.get('witnesses').get(firstIndex)!;
-    const newWitnessArgs: WitnessArgs = {
-      /* 65-byte zeros in hex */
-      lock: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
-    };
-    if (witness !== '0x') {
-      const witnessArgs = blockchain.WitnessArgs.unpack(bytes.bytify(witness));
-      const lock = witnessArgs.lock;
-      if (!!lock && !!newWitnessArgs.lock && !bytes.equal(lock, newWitnessArgs.lock)) {
-        throw new Error('Lock field in first witness is set aside for signature!');
-      }
-      const inputType = witnessArgs.inputType;
-      if (inputType) {
-        newWitnessArgs.inputType = inputType;
-      }
-      const outputType = witnessArgs.outputType;
-      if (outputType) {
-        newWitnessArgs.outputType = outputType;
-      }
+
+    if (extraCollectedSum.lt(extraNeededCapacity)) {
+      throw new Error(`Not enough CKB for change, ${extraCollectedSum} < ${extraNeededCapacity}`);
+    }
+
+    txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...extraCollectedCells));
+
+    const change2Capacity = extraCollectedSum.sub(changeOutputNeededCapacity);
+    if (change2Capacity.gt(61000000000)) {
+      changeOutput.cellOutput.capacity = changeOutputNeededCapacity.toHexString();
+      const changeOutput2: Cell = {
+        cellOutput: {
+          capacity: change2Capacity.toHexString(),
+          lock: senderLockScript,
+        },
+        data: '0x',
+      };
+      txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(changeOutput2));
+    } else {
+      changeOutput.cellOutput.capacity = extraCollectedSum.toHexString();
     }
-    witness = bytes.hexify(blockchain.WitnessArgs.pack(newWitnessArgs));
-    txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
   }
 
+  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 inputTypeWitness = xudtWitnessType.pack({ extension_data: [] });
+  const outputTypeWitness = xudtWitnessType.pack({ extension_data: [] });
+  const witnessArgs = blockchain.WitnessArgs.pack({
+    lock: lockWitness,
+    inputType: inputTypeWitness,
+    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!, options.privKey);
+  const Sig = hd.key.signRecoverable(message!, senderPrivKey);
   const tx = helpers.sealTransaction(txSkeleton, [Sig]);
-  const hash = await rpc.sendTransaction(tx, 'passthrough');
-  console.log('The transaction hash is', hash);
-  alert(`The transaction hash is ${hash}`);
+  console.log('tx: ', tx);
 
-  return hash;
+  const txHash = await rpc.sendTransaction(tx, 'passthrough');
+  console.log('The transaction hash is', txHash);
+  return { txHash, tx };
 }

package/templates/xudt/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@offckb/lumos-scaffold",
+  "name": "@offckb/xudt",
   "version": "0.1.0",
   "description": "",
   "main": "index.js",

package/templates/xudt/scheme.ts

@@ -0,0 +1,27 @@
+import { molecule, number } from '@ckb-lumos/codec';
+import { BytesOpt, Byte32, Bytes } from '@ckb-lumos/codec/lib/blockchain';
+const { vector, option, table } = molecule;
+
+const { Uint8 } = number;
+
+const Script = table(
+  {
+    codeHash: Byte32,
+    hashType: Uint8,
+    args: Bytes,
+  },
+  ['codeHash', 'hashType', 'args'],
+);
+const ScriptOpt = option(Script);
+const ScriptVecOpt = option(vector(Script));
+
+// specs: https://github.com/XuJiandong/rfcs/blob/xudt/rfcs/0052-extensible-udt/0052-extensible-udt.md#xudt-witness
+export const xudtWitnessType = table(
+  {
+    owner_script: ScriptOpt,
+    owner_signature: BytesOpt,
+    raw_extension_data: ScriptVecOpt,
+    extension_data: vector(Bytes),
+  },
+  ['owner_script', 'owner_signature', 'raw_extension_data', 'extension_data'],
+);

package/templates/xudt/util.ts

@@ -0,0 +1,66 @@
+import { helpers, Address, Script, hd, BI, CellDep } from '@ckb-lumos/lumos';
+import { values } from '@ckb-lumos/base';
+import { indexer, lumosConfig } from './ckb';
+import { TransactionSkeletonType } from '@ckb-lumos/helpers';
+import { number } from '@ckb-lumos/codec';
+
+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 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 function readTokenAmount(amount: string) {
+  return number.Uint128LE.unpack(amount);
+}