@offckb/cli 0.1.0-rc5 → 0.1.0-rc6

package/README.md

@@ -23,6 +23,9 @@ Start building on Nervos blockchain, right now, right away!
 - [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)
@@ -48,6 +51,8 @@ offckb list-hashes # list built-in scripts hashes, equals `ckb list-hashes`
 
 ## Get started
 
+### Step 1: Create A Project
+
 ```sh
 offckb init my-awesome-ckb-dapp
 
@@ -70,7 +75,9 @@ 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
@@ -83,7 +90,11 @@ CKB-Miner: 2024-03-04 14:35:17.567 +00:00 client INFO ckb_miner::miner  Found! #
 #...
 ```
 
-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

package/package.json

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

package/templates/xudt/index.tsx

@@ -1,33 +1,25 @@
 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';
+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 [amount, setAmount] = useState('');
-  const [cells, setCells] = useState<Cell[]>([]);
+  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());
     };
 
@@ -37,7 +29,6 @@ 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}$/;
 
@@ -50,57 +41,172 @@ export function App() {
       );
     }
   };
-
   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>
+    <>
+      <h2>Issue Custom Token</h2>
       <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>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).toLocaleString()}</li>
+        <li>Lock Script Hash: {lockScript && utils.computeScriptHash(lockScript)}</li>
       </ul>
       <br />
-      <label htmlFor="amount">Token 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 disabled={!enabledIssue} onClick={() => issueToken(privKey, amount).catch(alert)}>
-        Issue token
+      <button
+        disabled={!enabledIssue}
+        onClick={() =>
+          issueToken(privKey, amount)
+            .then((result) => {
+              setIssuedTokenCell(result.targetOutput);
+              setTxHash(result.hash);
+            })
+            .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
+      <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>
-          <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>
+          <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,74 +1,12 @@
-import { helpers, Address, Script, hd, config, Cell, commons, BI, utils, CellDep } 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';
-import { TransactionSkeletonType } from '@ckb-lumos/helpers';
 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 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;
@@ -152,14 +90,11 @@ export async function issueToken(privKey: string, amount: string) {
 
   const hash = await rpc.sendTransaction(tx, 'passthrough');
   console.log('The transaction hash is', hash);
-  alert(`The transaction hash is ${hash}`);
+  return { hash, targetOutput };
 }
 
-export async function queryIssuedTokenCells(privKey: string) {
-  const { lockScript } = generateAccountFromPrivateKey(privKey);
+export async function queryIssuedTokenCells(xudtArgs: HexString) {
   const xudtDeps = lumosConfig.SCRIPTS.XUDT;
-
-  const xudtArgs = utils.computeScriptHash(lockScript) + '00000000';
   const typeScript = {
     codeHash: xudtDeps.CODE_HASH,
     hashType: xudtDeps.HASH_TYPE,
@@ -174,6 +109,144 @@ export async function queryIssuedTokenCells(privKey: string) {
   return collected;
 }
 
-export function readTokenAmount(amount: string) {
-  return number.Uint128LE.unpack(amount);
+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: '0x0',
+      lock: senderLockScript,
+      type: typeScript,
+    },
+    data: bytes.hexify(number.Uint128LE.pack(changeOutputTokenAmount.toString(10))),
+  };
+
+  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;
+    }
+
+    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();
+    }
+  }
+
+  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!, senderPrivKey);
+  const tx = helpers.sealTransaction(txSkeleton, [Sig]);
+  console.log('tx: ', tx);
+
+  const txHash = await rpc.sendTransaction(tx, 'passthrough');
+  console.log('The transaction hash is', txHash);
+  return { txHash, tx };
 }

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);
+}