@offckb/cli 0.1.0-rc2 → 0.1.0-rc4

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,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.1.0-rc2",
+  "version": "0.1.0-rc4",
   "description": "ckb development environment for professionals",
   "author": "Retric Su <retric@cryptape.com>",
   "license": "MIT",
@@ -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/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>Transfer CKB</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script src="index.tsx" type="module"></script>
+  </body>
+</html>

package/templates/transfer/index.tsx

@@ -0,0 +1,89 @@
+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]);
+
+  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>Transfer CKB between addresses</h1>
+      <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>
+      <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="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
+        disabled={!enabled}
+        onClick={() => transfer({ amount, from: fromAddr, to: toAddr, privKey }).catch(alert)}
+      >
+        Transfer
+      </button>
+    </div>
+  );
+}

package/templates/xudt/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/templates/xudt/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/templates/xudt/tsconfig.json

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