@offckb/cli 0.1.0-rc1 → 0.1.0-rc3

package/README.md

@@ -5,24 +5,46 @@ ckb development environment for professionals
 ## Install
 
 ```sh
-git clone https://github.com/RetricSu/offckb.git
-cd offckb && alias offckb='yarn start'
-```
-
-eventually you will do simple
-```sh
-npm install -g offckb // not yet, todo
+npm install -g @offckb/cli
 ```
 
 ## Usage
 
 ```sh
 offckb node // start the devnet of CKB 
-offckb init // init a typescript boilerplate with lumos to get started with to build CKB DAPP,think 'hardhat init'
-offckb list-hashes // list scripts hashes, equals `ckb list-hashes`
+offckb init <project-name> // init a typescript boilerplate with lumos to get started with to build CKB DAPP,think 'hardhat init'
 offckb accounts // list 20 accounts info with prefund CKB tokens
+offckb list-hashes // list scripts hashes, equals `ckb list-hashes`
+```
+
+### Get started
+
+```sh
+offckb init my-awesome-ckb-dapp
+cd my-awesome-ckb-dapp
+yarn && yarn start
+
+## results
+yarn run v1.22.19
+$ parcel index.html
+Server running at http://localhost:1234
+✨ Built in 10ms
 ```
 
+open another terminal and start the devnet:
+
+```sh
+offckb node
+```
+
+open another terminal and check the accounts to use:
+
+```sh
+offckb accounts
+```
+
+Copy some private keys and visit http://localhost:1234 to play basic CKB transfer!
+
 ### Built-in scripts
 
 - [x] xUDT https://github.com/nervosnetwork/rfcs/pull/428

package/dist/cli.js

@@ -16,11 +16,20 @@ program
     .name('offckb')
     .description('CLI to provide full ckb development environment for professionals')
     .version(version);
+program
+    .command('init')
+    .description('init dapp project with lumos')
+    .argument('<string>', 'name of the dapp')
+    .action((str) => {
+    const name = str !== null && str !== void 0 ? str : 'offckb-dapp';
+    return (0, init_1.init)(name);
+});
+program.command('node').description('Use the CKB to start devnet').action(node_1.node);
+program.command('accounts').description('print account list info').action(accounts_1.accounts);
+program.command('list-hashes').description('Use the CKB to list blockchain scripts hashes').action(list_hashes_1.listHashes);
 // Define the CLI commands and options
 program.command('install').description('Install the ckb dependency binary').action(install_1.installDependency);
 program.command('genkey').description('generate 20 accounts').action(genkey_1.genkey);
-program.command('list-hashes').description('Use the CKB to list blockchain scripts hashes').action(list_hashes_1.listHashes);
-program.command('node').description('Use the CKB to start devnet').action(node_1.node);
 program.command('init-chain').description('Use the CKB to init devnet').action(init_chain_1.initChainIfNeeded);
 program.command('build-lumos-config').description('Use the CKB to generate lumos config.json').action(build_lumos_config_1.buildLumosConfig);
 program.command('build-accounts').description('generate accounts with prefunded CKB tokens').action(genkey_1.buildAccounts);
@@ -28,15 +37,6 @@ program
     .command('print-account-issue-info')
     .description('print account issue cells config toml sections')
     .action(genkey_1.printIssueSectionForToml);
-program.command('accounts').description('print account list info').action(accounts_1.accounts);
-program
-    .command('init')
-    .description('init dapp project with lumos')
-    .argument('<string>', 'name of the dapp')
-    .action((str) => {
-    const name = str !== null && str !== void 0 ? str : 'offckb-dapp';
-    return (0, init_1.init)(name);
-});
 // Parse command-line arguments
 program.parse(process.argv);
 // If no command is specified, display help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.1.0-rc1",
+  "version": "0.1.0-rc3",
   "description": "ckb development environment for professionals",
   "author": "Retric Su <retric@cryptape.com>",
   "license": "MIT",
@@ -16,7 +16,7 @@
     "dist",
     "account",
     "docker",
-    "templates"
+    "template"
   ],
   "private": false,
   "publishConfig": {

package/template/ckb.ts

@@ -0,0 +1,11 @@
+import { Indexer, RPC, config } from '@ckb-lumos/lumos';
+import devConfig from './config.json';
+
+export const lumosConfig: config.Config = devConfig as config.Config;
+//export const lumosConfig: config.Config = config.predefined.AGGRON4;
+
+export const CKB_RPC_URL = 'http://localhost:8114';
+//export const CKB_RPC_URL = "https://testnet.ckb.dev/rpc";
+
+export const rpc = new RPC(CKB_RPC_URL);
+export const indexer = new Indexer(CKB_RPC_URL);

package/template/config.json

@@ -0,0 +1,63 @@
+{
+  "PREFIX": "ckt",
+  "SCRIPTS": {
+    "SECP256K1_BLAKE160": {
+      "CODE_HASH": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x37f2b7799b199491f4732c572c086afdace0bf92992faf0b90bae44cdd119f9e",
+      "INDEX": "0x0",
+      "DEP_TYPE": "depGroup",
+      "SHORT_ID": 1
+    },
+    "SECP256K1_BLAKE160_MULTISIG": {
+      "CODE_HASH": "0x5c5069eb0857efc65e1bca0c07df34c31663b3622fd3876c876320fc9634e2a8",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x37f2b7799b199491f4732c572c086afdace0bf92992faf0b90bae44cdd119f9e",
+      "INDEX": "0x1",
+      "DEP_TYPE": "depGroup"
+    },
+    "DAO": {
+      "CODE_HASH": "0x82d76d1b75fe2fd9a27dfbaa65a039221a380d76c926f378d3f81cf3e7e13f2e",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x2",
+      "DEP_TYPE": "code",
+      "SHORT_ID": 2
+    },
+    "SUDT": {
+      "CODE_HASH": "0x6283a479a3cf5d4276cd93594de9f1827ab9b55c7b05b3d28e4c2e0a696cfefd",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x5",
+      "DEP_TYPE": "code"
+    },
+    "XUDT": {
+      "CODE_HASH": "0x1a1e4fef34f5982906f745b048fe7b1089647e82346074e0f32c2ece26cf6b1e",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x6",
+      "DEP_TYPE": "code"
+    },
+    "OMNILOCK": {
+      "CODE_HASH": "0x9c6933d977360f115a3e9cd5a2e0e475853681b80d775d93ad0f8969da343e56",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x7",
+      "DEP_TYPE": "code"
+    },
+    "ANYONE_CAN_PAY": {
+      "CODE_HASH": "0xe09352af0066f3162287763ce4ddba9af6bfaeab198dc7ab37f8c71c9e68bb5b",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x8",
+      "DEP_TYPE": "code"
+    },
+    "ALWAYS_SUCCESS": {
+      "CODE_HASH": "0xbb4469004225b39e983929db71fe2253cba1d49a76223e9e1d212cdca1f79f28",
+      "HASH_TYPE": "type",
+      "TX_HASH": "0x920bb4250dc6216c08ee0713f86b3fcb01bf444027b08b7d92db0ed1c0fb9214",
+      "INDEX": "0x9",
+      "DEP_TYPE": "code"
+    }
+  }
+}

package/template/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>happy coding with offckb</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="index.tsx" type="module"></script>
+  </body>
+</html>

package/template/index.tsx

@@ -0,0 +1,55 @@
+import React, { useEffect, useState } from 'react';
+import ReactDOM from 'react-dom';
+import { Script } from '@ckb-lumos/lumos';
+import { capacityOf, generateAccountFromPrivateKey, transfer } 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 [toAddr, setToAddr] = useState('');
+  const [amount, setAmount] = useState('');
+
+  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]);
+
+  return (
+    <div>
+      <label htmlFor="private-key">Private Key: </label>&nbsp;
+      <input id="private-key" type="text" onChange={(e) => setPrivKey(e.target.value)} />
+      <ul>
+        <li>CKB Address: {fromAddr}</li>
+        <li>
+          Current lock script:
+          <pre>{JSON.stringify(fromLock, null, 2)}</pre>
+        </li>
+
+        <li>Total capacity: {balance}</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)} />
+      <br />
+      <button onClick={() => transfer({ amount, from: fromAddr, to: toAddr, privKey }).catch(alert)}>Transfer</button>
+    </div>
+  );
+}

package/template/lib.ts

@@ -0,0 +1,153 @@
+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 { indexer, lumosConfig, rpc } from './ckb';
+const { ScriptValue } = values;
+
+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 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;
+}
+
+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,
+  });
+  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`,
+    );
+  }
+
+  // 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);
+  let collectedSum = BI.from(0);
+  const collected: Cell[] = [];
+  const collector = indexer.collector({ lock: fromScript, 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 transferOutput: Cell = {
+    cellOutput: {
+      capacity: BI.from(options.amount).toHexString(),
+      lock: toScript,
+    },
+    data: '0x',
+  };
+
+  const changeOutput: Cell = {
+    cellOutput: {
+      capacity: collectedSum.sub(neededCapacity).toHexString(),
+      lock: fromScript,
+    },
+    data: '0x',
+  };
+
+  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'));
+    }
+    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;
+      }
+    }
+    witness = bytes.hexify(blockchain.WitnessArgs.pack(newWitnessArgs));
+    txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
+  }
+
+  txSkeleton = commons.common.prepareSigningEntries(txSkeleton);
+  const message = txSkeleton.get('signingEntries').get(0)?.message;
+  const Sig = hd.key.signRecoverable(message!, options.privKey);
+  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}`);
+
+  return hash;
+}

package/template/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@offckb/lumos-scaffold",
+  "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"
+  }
+}

package/template/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "lib": ["dom"],
+    "jsx": "react",
+    "module": "CommonJS",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true
+  }
+}