@offckb/cli 0.3.0-canary-884fccd.0 → 0.3.0-canary-1bb6394.0

package/dist/cfg/setting.d.ts

@@ -1,11 +1,20 @@
-import { AxiosProxyConfig } from 'axios';
 export declare const configPath: string;
 export declare const dataPath: string;
 export declare const cachePath: string;
 export declare const packageSrcPath: string;
 export declare const packageRootPath: string;
+export interface ProxyBasicCredentials {
+    username: string;
+    password: string;
+}
+export interface ProxyConfig {
+    host: string;
+    port: number;
+    auth?: ProxyBasicCredentials;
+    protocol?: string;
+}
 export interface Settings {
-    proxy?: AxiosProxyConfig;
+    proxy?: ProxyConfig;
     rpc: {
         proxyPort: number;
     };

package/dist/cli.js

@@ -97,19 +97,19 @@ program
 program.command('inject-config').description('Add offckb.config.ts to your frontend workspace').action(inject_config_1.injectConfig);
 program.command('sync-scripts').description('Sync scripts json files in your frontend workspace').action(sync_scripts_1.syncScripts);
 program
-    .command('deposit [toAddress] [amountInShannon]')
+    .command('deposit [toAddress] [amountInCKB]')
     .description('Deposit CKB tokens to address, only devnet and testnet')
     .option('--network <network>', 'Specify the network to deposit to', 'devnet')
-    .action((toAddress, amount, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, deposit_1.deposit)(toAddress, amount, options);
+    .action((toAddress, amountInCKB, options) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, deposit_1.deposit)(toAddress, amountInCKB, options);
 }));
 program
-    .command('transfer [toAddress] [amountInShannon]')
+    .command('transfer [toAddress] [amountInCKB]')
     .description('Transfer CKB tokens to address, only devnet and testnet')
     .option('--network <network>', 'Specify the network to transfer to', 'devnet')
     .option('--privkey <privkey>', 'Specify the private key to deploy scripts')
-    .action((toAddress, amount, options) => __awaiter(void 0, void 0, void 0, function* () {
-    return (0, transfer_1.transfer)(toAddress, amount, options);
+    .action((toAddress, amountInCKB, options) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, transfer_1.transfer)(toAddress, amountInCKB, options);
 }));
 program
     .command('balance [toAddress]')

package/dist/cmd/balance.js

@@ -10,19 +10,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.balanceOf = void 0;
-const lumos_1 = require("@ckb-lumos/lumos");
-const ckb_1 = require("../util/ckb");
+const ckb_1 = require("../sdk/ckb");
 const validator_1 = require("../util/validator");
 const type_1 = require("../util/type");
 function balanceOf(address, opt = { network: type_1.Network.devnet }) {
     return __awaiter(this, void 0, void 0, function* () {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
-        const ckb = new ckb_1.CKB(network);
-        const lumosConfig = ckb.getLumosConfig();
-        const balance = yield ckb.capacityOf(address, lumosConfig);
-        const balanceInCKB = balance.div(lumos_1.BI.from('100000000'));
+        const ckb = new ckb_1.CKB({ network });
+        const balanceInCKB = yield ckb.balance(address);
         console.log(`Balance: ${balanceInCKB} CKB`);
+        process.exit(0);
     });
 }
 exports.balanceOf = balanceOf;

package/dist/cmd/deposit.d.ts

@@ -1,4 +1,4 @@
 import { NetworkOption } from '../util/type';
 export interface DepositOptions extends NetworkOption {
 }
-export declare function deposit(toAddress: string, amount: string, opt?: DepositOptions): Promise<void>;
+export declare function deposit(toAddress: string, amountInCKB: string, opt?: DepositOptions): Promise<void>;

package/dist/cmd/deposit.js

@@ -10,29 +10,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deposit = void 0;
-const ckb_1 = require("../util/ckb");
+const ckb_1 = require("../sdk/ckb");
 const account_1 = require("../cfg/account");
 const type_1 = require("../util/type");
 const link_1 = require("../util/link");
 const validator_1 = require("../util/validator");
 const request_1 = require("../util/request");
-function deposit(toAddress, amount, opt = { network: type_1.Network.devnet }) {
+function deposit(toAddress, amountInCKB, opt = { network: type_1.Network.devnet }) {
     return __awaiter(this, void 0, void 0, function* () {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
-        const ckb = new ckb_1.CKB(network);
-        const lumosConfig = ckb.getLumosConfig();
+        const ckb = new ckb_1.CKB({ network });
         if (network === 'testnet') {
             return yield depositFromTestnetFaucet(toAddress, ckb);
         }
         // deposit from devnet miner
-        const from = ckb_1.CKB.generateAccountFromPrivateKey(account_1.ckbDevnetMinerAccount.privkey, lumosConfig);
+        const privateKey = account_1.ckbDevnetMinerAccount.privkey;
         const txHash = yield ckb.transfer({
-            from: from.address,
-            to: toAddress,
-            privKey: from.privKey,
-            amount,
-        }, lumosConfig);
+            toAddress,
+            privateKey,
+            amountInCKB,
+        });
         console.log('tx hash: ', txHash);
     });
 }
@@ -40,29 +38,33 @@ exports.deposit = deposit;
 function depositFromTestnetFaucet(ckbAddress, ckb) {
     return __awaiter(this, void 0, void 0, function* () {
         console.log('testnet faucet only supports fixed-amount claim: 10,000 CKB');
-        const lumosConfig = ckb.getLumosConfig();
         const randomAccountPrivateKey = '0x' + generateHex(64);
-        const randomAccount = ckb_1.CKB.generateAccountFromPrivateKey(randomAccountPrivateKey, lumosConfig);
-        console.log(`use random account to claim from faucet: \n\nprivate key: ${randomAccountPrivateKey}\n\n address: ${randomAccount.address}`);
+        const randomAccountAddress = yield ckb.buildSecp256k1Address(randomAccountPrivateKey);
+        console.log(`use random account to claim from faucet: \n\nprivate key: ${randomAccountPrivateKey}\n\n address: ${randomAccountAddress}`);
         try {
-            yield sendClaimRequest(randomAccount.address);
-            console.log('Wait for 4 blocks to transfer all from random account to your account..');
+            const claimResponse = yield sendClaimRequest(randomAccountAddress);
+            console.log('Wait for claim transaction confirmed to transfer all from random account to your account..');
             console.log('You can transfer by yourself if it ends up fails..');
-            yield ckb.indexer.waitForSync(-4);
-            const txHash = yield ckb.transferAll(randomAccount.privKey, ckbAddress, lumosConfig);
-            console.log(`Done, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
+            if (claimResponse.txHash != null) {
+                yield ckb.waitForTxConfirm(claimResponse.txHash);
+            }
+            else {
+                yield ckb.waitForBlocksBy(4); // wait 4 blocks
+            }
         }
         catch (error) {
             console.log(error);
-            throw new Error('request failed.');
+            throw new Error('claim request failed.');
         }
+        const txHash = yield ckb.transferAll({ privateKey: randomAccountPrivateKey, toAddress: ckbAddress });
+        console.log(`Done, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
     });
 }
 function sendClaimRequest(toAddress) {
     return __awaiter(this, void 0, void 0, function* () {
         const url = 'https://faucet-api.nervos.org/claim_events'; // Replace 'YOUR_API_ENDPOINT' with the actual API endpoint
         const headers = {
-            'User-Agent': 'axios-requests/2.31.0',
+            'User-Agent': 'node-fetch-requests/v2',
             'Accept-Encoding': 'gzip, deflate',
             Accept: '*/*',
             Connection: 'keep-alive',
@@ -71,22 +73,18 @@ function sendClaimRequest(toAddress) {
         const body = JSON.stringify({
             claim_event: {
                 address_hash: toAddress,
-                amount: '10000',
+                amount: '10000', // unit: CKB
             },
         });
         const config = {
             method: 'post',
-            url: url,
             headers: headers,
-            data: body,
+            body,
         };
-        try {
-            const response = yield request_1.Request.send(config);
-            console.log('send claim request, status: ', response.status); // Handle the response data here
-        }
-        catch (error) {
-            console.error('Error:', error);
-        }
+        const response = yield request_1.Request.send(url, config);
+        console.log('send claim request, status: ', response.status); // Handle the response data here
+        const jsonResponse = yield response.json();
+        return jsonResponse.data.attributes;
     });
 }
 function generateHex(length) {

package/dist/cmd/transfer.d.ts

@@ -2,4 +2,4 @@ import { NetworkOption } from '../util/type';
 export interface TransferOptions extends NetworkOption {
     privkey?: string | null;
 }
-export declare function transfer(toAddress: string, amount: string, opt?: TransferOptions): Promise<void>;
+export declare function transfer(toAddress: string, amountInCKB: string, opt?: TransferOptions): Promise<void>;

package/dist/cmd/transfer.js

@@ -10,11 +10,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transfer = void 0;
-const ckb_1 = require("../util/ckb");
+const ckb_1 = require("../sdk/ckb");
 const type_1 = require("../util/type");
 const link_1 = require("../util/link");
 const validator_1 = require("../util/validator");
-function transfer(toAddress, amount, opt = { network: type_1.Network.devnet }) {
+function transfer(toAddress, amountInCKB, opt = { network: type_1.Network.devnet }) {
     return __awaiter(this, void 0, void 0, function* () {
         const network = opt.network;
         (0, validator_1.validateNetworkOpt)(network);
@@ -22,15 +22,12 @@ function transfer(toAddress, amount, opt = { network: type_1.Network.devnet }) {
             throw new Error('--privkey is required!');
         }
         const privateKey = opt.privkey;
-        const ckb = new ckb_1.CKB(network);
-        const lumosConfig = ckb.getLumosConfig();
-        const from = ckb_1.CKB.generateAccountFromPrivateKey(privateKey, lumosConfig);
+        const ckb = new ckb_1.CKB({ network });
         const txHash = yield ckb.transfer({
-            from: from.address,
-            to: toAddress,
-            amount: amount,
-            privKey: privateKey,
-        }, lumosConfig);
+            toAddress,
+            amountInCKB,
+            privateKey,
+        });
         if (network === 'testnet') {
             console.log(`Successfully transfer, check ${(0, link_1.buildTestnetTxLink)(txHash)} for details.`);
             return;

package/dist/node/install.js

@@ -97,10 +97,9 @@ exports.downloadCKBBinaryAndUnzip = downloadCKBBinaryAndUnzip;
 function downloadAndSaveCKBBinary(version, tempFilePath) {
     return __awaiter(this, void 0, void 0, function* () {
         const downloadURL = buildDownloadUrl(version);
-        const response = yield request_1.Request.get(downloadURL, {
-            responseType: 'arraybuffer',
-        });
-        fs.writeFileSync(tempFilePath, response.data);
+        const response = yield request_1.Request.send(downloadURL);
+        const arrayBuffer = yield response.arrayBuffer();
+        fs.writeFileSync(tempFilePath, Buffer.from(arrayBuffer));
     });
 }
 exports.downloadAndSaveCKBBinary = downloadAndSaveCKBBinary;

package/dist/sdk/ckb.d.ts

@@ -1,8 +1,9 @@
 import { ccc, Script } from '@ckb-ccc/core';
 import { Network } from '../util/type';
-import { HexString } from '@ckb-lumos/lumos';
+import { HexNumber, HexString } from '@ckb-lumos/lumos';
 export declare class CKBProps {
     network?: Network;
+    feeRate?: number;
     isEnableProxyRpc?: boolean;
 }
 export interface DeploymentResult {
@@ -12,12 +13,25 @@ export interface DeploymentResult {
     isTypeId: boolean;
     typeId?: Script;
 }
+export interface TransferOption {
+    privateKey: HexString;
+    toAddress: string;
+    amountInCKB: HexNumber;
+}
+export type TransferAllOption = Pick<TransferOption, 'privateKey' | 'toAddress'>;
 export declare class CKB {
     network: Network;
+    feeRate: number;
+    isEnableProxyRpc: boolean;
     private client;
-    constructor({ network, isEnableProxyRpc }: CKBProps);
-    private buildSigner;
+    constructor({ network, feeRate, isEnableProxyRpc }: CKBProps);
+    buildSigner(privateKey: HexString): ccc.SignerCkbPrivateKey;
+    buildSecp256k1Address(privateKey: HexString): Promise<string>;
     waitForTxConfirm(txHash: HexString, timeout?: number): Promise<void>;
+    waitForBlocksBy(interval: number): Promise<void>;
+    balance(address: string): Promise<string>;
+    transfer({ privateKey, toAddress, amountInCKB }: TransferOption): Promise<HexString>;
+    transferAll({ privateKey, toAddress }: TransferAllOption): Promise<HexString>;
     deployScript(scriptBinBytes: Uint8Array, privateKey: string): Promise<DeploymentResult>;
     deployNewTypeIDScript(scriptBinBytes: Uint8Array, privateKey: string): Promise<DeploymentResult>;
     upgradeTypeIdScript(scriptName: string, newScriptBinBytes: Uint8Array, privateKey: HexString): Promise<DeploymentResult>;

package/dist/sdk/ckb.js

@@ -22,11 +22,13 @@ class CKBProps {
 }
 exports.CKBProps = CKBProps;
 class CKB {
-    constructor({ network = type_1.Network.devnet, isEnableProxyRpc = false }) {
+    constructor({ network = type_1.Network.devnet, feeRate = 1000, isEnableProxyRpc = false }) {
         if (!(0, validator_1.isValidNetworkString)(network)) {
             throw new Error('invalid network option');
         }
         this.network = network;
+        this.feeRate = feeRate;
+        this.isEnableProxyRpc = isEnableProxyRpc;
         if (isEnableProxyRpc === true) {
             this.client =
                 network === 'mainnet'
@@ -54,6 +56,13 @@ class CKB {
         const signer = new core_1.ccc.SignerCkbPrivateKey(this.client, privateKey);
         return signer;
     }
+    buildSecp256k1Address(privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = this.buildSigner(privateKey);
+            const address = yield signer.getAddressObjSecp256k1();
+            return address.toString();
+        });
+    }
     waitForTxConfirm(txHash, timeout = 60000) {
         return __awaiter(this, void 0, void 0, function* () {
             const query = () => __awaiter(this, void 0, void 0, function* () {
@@ -68,6 +77,71 @@ class CKB {
             return waitFor(query, timeout, 5000);
         });
     }
+    waitForBlocksBy(interval) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (interval < 0)
+                throw new Error('interval must be number >= 0');
+            const timeout = interval * 50000; // block interval is 18 secs, we set limit to 30s
+            const tip = yield this.client.getTip();
+            const blockNum = tip + BigInt(interval);
+            const query = () => __awaiter(this, void 0, void 0, function* () {
+                const res = yield this.client.getBlockByNumber(blockNum);
+                if (res) {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            });
+            return waitFor(query, timeout, 5000);
+        });
+    }
+    balance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const lock = (yield core_1.ccc.Address.fromString(address, this.client)).script;
+            const balanceInShannon = yield this.client.getBalanceSingle(lock);
+            const balanceInCKB = core_1.ccc.fixedPointToString(balanceInShannon);
+            return balanceInCKB;
+        });
+    }
+    transfer({ privateKey, toAddress, amountInCKB }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = this.buildSigner(privateKey);
+            const to = yield core_1.ccc.Address.fromString(toAddress, this.client);
+            const tx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        capacity: core_1.ccc.fixedPointFrom(amountInCKB),
+                        lock: to.script,
+                    },
+                ],
+            });
+            yield tx.completeInputsByCapacity(signer);
+            yield tx.completeFeeBy(signer, this.feeRate);
+            const txHash = yield signer.sendTransaction(tx);
+            return txHash;
+        });
+    }
+    transferAll({ privateKey, toAddress }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = this.buildSigner(privateKey);
+            const to = yield core_1.ccc.Address.fromString(toAddress, this.client);
+            const balanceInCKB = yield this.balance((yield signer.getRecommendedAddressObj()).toString());
+            // leave 0.001 ckb for tx fee
+            const amountInCKB = core_1.ccc.fixedPointFrom(balanceInCKB) - core_1.ccc.fixedPointFrom(0.001);
+            const tx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        capacity: core_1.ccc.fixedPointFrom(amountInCKB),
+                        lock: to.script,
+                    },
+                ],
+            });
+            yield tx.completeInputsByCapacity(signer);
+            const txHash = yield signer.sendTransaction(tx);
+            return txHash;
+        });
+    }
     deployScript(scriptBinBytes, privateKey) {
         return __awaiter(this, void 0, void 0, function* () {
             const signer = this.buildSigner(privateKey);
@@ -81,7 +155,7 @@ class CKB {
                 outputsData: [scriptBinBytes],
             });
             yield tx.completeInputsByCapacity(signer);
-            yield tx.completeFeeBy(signer, 1000);
+            yield tx.completeFeeBy(signer, this.feeRate);
             const txHash = yield signer.sendTransaction(tx);
             return { txHash, tx, scriptOutputCellIndex: 0, isTypeId: false };
         });
@@ -104,7 +178,7 @@ class CKB {
                 throw new Error('Unexpected disappeared output');
             }
             typeIdTx.outputs[0].type.args = core_1.ccc.hashTypeId(typeIdTx.inputs[0], 0);
-            yield typeIdTx.completeFeeBy(signer, 1000);
+            yield typeIdTx.completeFeeBy(signer, this.feeRate);
             const txHash = yield signer.sendTransaction(typeIdTx);
             return { txHash, tx: typeIdTx, scriptOutputCellIndex: 0, isTypeId: true, typeId: typeIdTx.outputs[0].type };
         });
@@ -152,7 +226,7 @@ class CKB {
                 throw new Error('Unexpected disappeared output');
             }
             typeIdTx.outputs[0].type.args = typeIdArgs;
-            yield typeIdTx.completeFeeBy(signer, 1000);
+            yield typeIdTx.completeFeeBy(signer, this.feeRate);
             const txHash = yield signer.sendTransaction(typeIdTx);
             return { txHash, tx: typeIdTx, scriptOutputCellIndex: 0, isTypeId: true, typeId: typeIdTx.outputs[0].type };
         });

package/dist/tools/moleculec-es.js

@@ -57,10 +57,9 @@ class MoleculecES {
     static downloadAndSaveMoleculeES(version, tempFilePath) {
         return __awaiter(this, void 0, void 0, function* () {
             const downloadURL = MoleculecES.buildDownloadUrl(version);
-            const response = yield request_1.Request.get(downloadURL, {
-                responseType: 'arraybuffer',
-            });
-            fs_1.default.writeFileSync(tempFilePath, response.data);
+            const response = yield request_1.Request.send(downloadURL);
+            const arrayBuffer = yield response.arrayBuffer();
+            fs_1.default.writeFileSync(tempFilePath, Buffer.from(arrayBuffer));
         });
     }
     static buildDownloadUrl(version) {

package/dist/util/request.d.ts

@@ -1,8 +1,8 @@
-import axios, { AxiosProxyConfig, AxiosRequestConfig } from 'axios';
+import { ProxyConfig } from '../cfg/setting';
+import fetch, { RequestInit } from 'node-fetch';
 export declare class Request {
-    static proxy: axios.AxiosProxyConfig | undefined;
-    static send(_config: AxiosRequestConfig): Promise<axios.AxiosResponse<any, any>>;
-    static get(url: string, _config?: AxiosRequestConfig): Promise<axios.AxiosResponse<any, any>>;
-    static parseProxyUrl(url: string): AxiosProxyConfig;
-    static proxyConfigToUrl(proxy: AxiosProxyConfig): string;
+    static proxy: ProxyConfig | undefined;
+    static send(url: string, options?: RequestInit): Promise<fetch.Response>;
+    static parseProxyUrl(url: string): ProxyConfig;
+    static proxyConfigToUrl(proxy: ProxyConfig): string;
 }

package/dist/util/request.js

@@ -13,20 +13,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Request = void 0;
-const axios_1 = __importDefault(require("axios"));
 const setting_1 = require("../cfg/setting");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const node_fetch_1 = __importDefault(require("node-fetch"));
 class Request {
-    static send(_config) {
+    static send(url, options = {}) {
         return __awaiter(this, void 0, void 0, function* () {
-            const config = this.proxy ? Object.assign({ proxy: this.proxy }, _config) : _config;
-            return yield (0, axios_1.default)(config);
-        });
-    }
-    static get(url, _config) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const config = this.proxy ? Object.assign({ proxy: this.proxy }, _config) : _config;
-            console.log(config);
-            return yield axios_1.default.get(url, config);
+            const agent = this.proxy ? new https_proxy_agent_1.HttpsProxyAgent(this.proxyConfigToUrl(this.proxy)) : undefined;
+            const opt = Object.assign({ agent }, options);
+            try {
+                const response = yield (0, node_fetch_1.default)(url, opt);
+                if (!response.ok) {
+                    throw new Error(`HTTP error! Status: ${response.status}, URL: ${response.url}`);
+                }
+                return yield response;
+            }
+            catch (error) {
+                throw new Error(`fetch error! ${error.message}`);
+            }
         });
     }
     static parseProxyUrl(url) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.3.0-canary-884fccd.0",
+  "version": "0.3.0-canary-1bb6394.0",
   "description": "ckb development network for your first try",
   "author": "CKB EcoFund",
   "license": "MIT",
@@ -47,6 +47,7 @@
   "devDependencies": {
     "@types/adm-zip": "^0.5.5",
     "@types/node": "^20.11.19",
+    "@types/node-fetch": "^2.6.11",
     "@types/semver": "^7.5.7",
     "@types/tar": "^6.1.11",
     "@typescript-eslint/eslint-plugin": "^7.0.2",
@@ -65,11 +66,12 @@
     "@inquirer/prompts": "^4.1.0",
     "@types/http-proxy": "^1.17.15",
     "adm-zip": "^0.5.10",
-    "axios": "^1.6.7",
     "child_process": "^1.0.2",
     "ckb-transaction-dumper": "^0.4.0",
     "commander": "^12.0.0",
     "http-proxy": "^1.18.1",
+    "https-proxy-agent": "^7.0.5",
+    "node-fetch": "2",
     "semver": "^7.6.0",
     "tar": "^6.2.1"
   }

package/dist/util/ckb.d.ts

@@ -1,141 +0,0 @@
-import { Address, BI, Indexer, RPC, Script, config } from '@ckb-lumos/lumos';
-import { Network } from './type';
-export type Account = {
-    lockScript: Script;
-    address: Address;
-    pubKey: string;
-    privKey: string;
-};
-interface Options {
-    from: string;
-    to: string;
-    amount: string;
-    privKey: string;
-}
-export declare class CKB {
-    network: Network;
-    rpc_url: string;
-    rpc: RPC;
-    indexer: Indexer;
-    constructor(network?: Network);
-    static generateAccountFromPrivateKey(privKey: string, lumosConfig: config.Config): Account;
-    getLumosConfig(): config.Config | {
-        PREFIX: string;
-        SCRIPTS: {
-            SECP256K1_BLAKE160: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            SECP256K1_BLAKE160_MULTISIG: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            DAO: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            SUDT: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            ANYONE_CAN_PAY: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            OMNILOCK: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            XUDT: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-        };
-    } | {
-        PREFIX: string;
-        SCRIPTS: {
-            SECP256K1_BLAKE160: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            SECP256K1_BLAKE160_MULTISIG: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            DAO: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            SUDT: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            ANYONE_CAN_PAY: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "depGroup";
-                SHORT_ID: number;
-            };
-            OMNILOCK: {
-                CODE_HASH: string;
-                HASH_TYPE: "type";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-            XUDT: {
-                CODE_HASH: string;
-                HASH_TYPE: "data1";
-                TX_HASH: string;
-                INDEX: string;
-                DEP_TYPE: "code";
-            };
-        };
-    };
-    initializedLumosConfig(): void;
-    capacityOf(address: string, lumosConfig: config.Config): Promise<BI>;
-    transfer(options: Options, lumosConfig: config.Config): Promise<string>;
-    transferAll(privateKey: string, toAddress: string, lumosConfig: config.Config): Promise<string>;
-}
-export declare function readPredefinedDevnetLumosConfig(): config.Config;
-export {};

package/dist/util/ckb.js

@@ -1,312 +0,0 @@
-"use strict";
-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());
-    });
-};
-var __asyncValues = (this && this.__asyncValues) || function (o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.readPredefinedDevnetLumosConfig = exports.CKB = void 0;
-const lumos_1 = require("@ckb-lumos/lumos");
-const base_1 = require("@ckb-lumos/base");
-const codec_1 = require("@ckb-lumos/codec");
-const validator_1 = require("./validator");
-const type_1 = require("./type");
-const system_scripts_1 = require("../cmd/system-scripts");
-const { ScriptValue } = base_1.values;
-const networks = {
-    devnet: {
-        rpc_url: 'http://127.0.0.1:8114',
-        rpc: new lumos_1.RPC('http://127.0.0.1:8114'),
-        indexer: new lumos_1.Indexer('http://127.0.0.1:8114'),
-    },
-    testnet: {
-        rpc_url: 'https://testnet.ckb.dev/rpc',
-        rpc: new lumos_1.RPC('https://testnet.ckb.dev/rpc'),
-        indexer: new lumos_1.Indexer('https://testnet.ckb.dev/rpc'),
-    },
-    mainnet: {
-        rpc_url: 'https://mainnet.ckb.dev/rpc',
-        rpc: new lumos_1.RPC('https://mainnet.ckb.dev/rpc'),
-        indexer: new lumos_1.Indexer('https://mainnet.ckb.dev/rpc'),
-    },
-};
-class CKB {
-    constructor(network = type_1.Network.devnet) {
-        if (!(0, validator_1.isValidNetworkString)(network)) {
-            throw new Error('invalid network option');
-        }
-        this.network = network;
-        this.rpc_url = networks[network].rpc_url;
-        this.rpc = networks[network].rpc;
-        this.indexer = networks[network].indexer;
-    }
-    static generateAccountFromPrivateKey(privKey, lumosConfig) {
-        const pubKey = lumos_1.hd.key.privateToPublic(privKey);
-        const args = lumos_1.hd.key.publicKeyToBlake160(pubKey);
-        const template = lumosConfig.SCRIPTS['SECP256K1_BLAKE160'];
-        const lockScript = {
-            codeHash: template.CODE_HASH,
-            hashType: template.HASH_TYPE,
-            args: args,
-        };
-        const address = lumos_1.helpers.encodeToAddress(lockScript, { config: lumosConfig });
-        return {
-            lockScript,
-            address,
-            pubKey,
-            privKey,
-        };
-    }
-    getLumosConfig() {
-        if (this.network === type_1.Network.devnet) {
-            return readPredefinedDevnetLumosConfig();
-        }
-        if (this.network === type_1.Network.testnet) {
-            return lumos_1.config.predefined.AGGRON4;
-        }
-        return lumos_1.config.predefined.LINA;
-    }
-    initializedLumosConfig() {
-        return lumos_1.config.initializeConfig(this.getLumosConfig());
-    }
-    capacityOf(address, lumosConfig) {
-        var _a, e_1, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            const collector = this.indexer.collector({
-                lock: lumos_1.helpers.parseAddress(address, { config: lumosConfig }),
-            });
-            let balance = lumos_1.BI.from(0);
-            try {
-                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const cell = _c;
-                    balance = balance.add(cell.cellOutput.capacity);
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-            return balance;
-        });
-    }
-    transfer(options, lumosConfig) {
-        var _a, e_2, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            let txSkeleton = lumos_1.helpers.TransactionSkeleton({});
-            const fromScript = lumos_1.helpers.parseAddress(options.from, {
-                config: lumosConfig,
-            });
-            const toScript = lumos_1.helpers.parseAddress(options.to, { config: lumosConfig });
-            if (lumos_1.BI.from(options.amount).lt(lumos_1.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 = lumos_1.BI.from(options.amount).add(100000);
-            let collectedSum = lumos_1.BI.from(0);
-            const collected = [];
-            const collector = this.indexer.collector({ lock: fromScript, type: 'empty' });
-            try {
-                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const cell = _c;
-                    collectedSum = collectedSum.add(cell.cellOutput.capacity);
-                    collected.push(cell);
-                    if (collectedSum >= neededCapacity)
-                        break;
-                }
-            }
-            catch (e_2_1) { e_2 = { error: e_2_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_2) throw e_2.error; }
-            }
-            if (collectedSum.lt(neededCapacity)) {
-                throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
-            }
-            const transferOutput = {
-                cellOutput: {
-                    capacity: lumos_1.BI.from(options.amount).toHexString(),
-                    lock: toScript,
-                },
-                data: '0x',
-            };
-            const changeOutput = {
-                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 = txSkeleton.get('witnesses').get(firstIndex);
-                const newWitnessArgs = {
-                    /* 65-byte zeros in hex */
-                    lock: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
-                };
-                if (witness !== '0x') {
-                    const witnessArgs = base_1.blockchain.WitnessArgs.unpack(codec_1.bytes.bytify(witness));
-                    const lock = witnessArgs.lock;
-                    if (!!lock && !!newWitnessArgs.lock && !codec_1.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 = codec_1.bytes.hexify(base_1.blockchain.WitnessArgs.pack(newWitnessArgs));
-                txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
-            }
-            txSkeleton = lumos_1.commons.common.prepareSigningEntries(txSkeleton);
-            const message = txSkeleton.get('signingEntries').get(0).message;
-            const Sig = lumos_1.hd.key.signRecoverable(message, options.privKey);
-            const tx = lumos_1.helpers.sealTransaction(txSkeleton, [Sig]);
-            const hash = yield this.rpc.sendTransaction(tx, 'passthrough');
-            return hash;
-        });
-    }
-    transferAll(privateKey, toAddress, lumosConfig) {
-        var _a, e_3, _b, _c;
-        return __awaiter(this, void 0, void 0, function* () {
-            let txSkeleton = lumos_1.helpers.TransactionSkeleton({});
-            const from = CKB.generateAccountFromPrivateKey(privateKey, lumosConfig);
-            const fromScript = from.lockScript;
-            const toScript = lumos_1.helpers.parseAddress(toAddress, { config: lumosConfig });
-            const balance = yield this.capacityOf(from.address, lumosConfig);
-            // additional 0.001 ckb for tx fee
-            // the tx fee could calculated by tx size
-            // this is just a simple example
-            const neededCapacity = balance.sub(100000);
-            let collectedSum = lumos_1.BI.from(0);
-            const collected = [];
-            const collector = this.indexer.collector({ lock: fromScript, type: 'empty' });
-            try {
-                for (var _d = true, _e = __asyncValues(collector.collect()), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
-                    _c = _f.value;
-                    _d = false;
-                    const cell = _c;
-                    collectedSum = collectedSum.add(cell.cellOutput.capacity);
-                    collected.push(cell);
-                    if (collectedSum >= neededCapacity)
-                        break;
-                }
-            }
-            catch (e_3_1) { e_3 = { error: e_3_1 }; }
-            finally {
-                try {
-                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
-                }
-                finally { if (e_3) throw e_3.error; }
-            }
-            if (collectedSum.lt(neededCapacity)) {
-                throw new Error(`Not enough CKB, ${collectedSum} < ${neededCapacity}`);
-            }
-            const transferOutput = {
-                cellOutput: {
-                    capacity: neededCapacity.toHexString(),
-                    lock: toScript,
-                },
-                data: '0x',
-            };
-            txSkeleton = txSkeleton.update('inputs', (inputs) => inputs.push(...collected));
-            txSkeleton = txSkeleton.update('outputs', (outputs) => outputs.push(transferOutput));
-            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 = txSkeleton.get('witnesses').get(firstIndex);
-                const newWitnessArgs = {
-                    /* 65-byte zeros in hex */
-                    lock: '0x0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000',
-                };
-                if (witness !== '0x') {
-                    const witnessArgs = base_1.blockchain.WitnessArgs.unpack(codec_1.bytes.bytify(witness));
-                    const lock = witnessArgs.lock;
-                    if (!!lock && !!newWitnessArgs.lock && !codec_1.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 = codec_1.bytes.hexify(base_1.blockchain.WitnessArgs.pack(newWitnessArgs));
-                txSkeleton = txSkeleton.update('witnesses', (witnesses) => witnesses.set(firstIndex, witness));
-            }
-            txSkeleton = lumos_1.commons.common.prepareSigningEntries(txSkeleton);
-            const message = txSkeleton.get('signingEntries').get(0).message;
-            const Sig = lumos_1.hd.key.signRecoverable(message, privateKey);
-            const tx = lumos_1.helpers.sealTransaction(txSkeleton, [Sig]);
-            const hash = yield this.rpc.sendTransaction(tx, 'passthrough');
-            return hash;
-        });
-    }
-}
-exports.CKB = CKB;
-function readPredefinedDevnetLumosConfig() {
-    try {
-        const systemScripts = (0, system_scripts_1.getSystemScriptsFromListHashes)();
-        if (systemScripts) {
-            return (0, system_scripts_1.toLumosConfig)(systemScripts);
-        }
-        throw new Error('systemScripts not found!');
-    }
-    catch (error) {
-        throw new Error('getSystemScriptsFromListHashes error' + error.message);
-    }
-}
-exports.readPredefinedDevnetLumosConfig = readPredefinedDevnetLumosConfig;