@offckb/cli 0.3.0-rc3 → 0.3.0-rc5

package/dist/scripts/private.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCCCDevnetKnownScripts = void 0;
+//todo: extract getSystemScriptsFromListHashes/toCCCKnownScripts from cmd folder
+const system_scripts_1 = require("../cmd/system-scripts");
+function buildCCCDevnetKnownScripts() {
+    const devnetSystemScripts = (0, system_scripts_1.getSystemScriptsFromListHashes)();
+    if (devnetSystemScripts == null) {
+        throw new Error('can not getSystemScriptsFromListHashes in devnet');
+    }
+    const devnetKnownScripts = (0, system_scripts_1.toCCCKnownScripts)(devnetSystemScripts);
+    return devnetKnownScripts;
+}
+exports.buildCCCDevnetKnownScripts = buildCCCDevnetKnownScripts;

package/dist/scripts/util.d.ts

@@ -1,3 +1,3 @@
 import { MyScriptsRecord } from '../scripts/type';
-import { Network } from '../util/type';
+import { Network } from '../type/base';
 export declare function readUserDeployedScriptsInfo(network: Network): MyScriptsRecord;

package/dist/scripts/util.js

@@ -42,7 +42,7 @@ function readUserDeployedScriptsInfo(network) {
         if (newestFilePath) {
             try {
                 // Read the file content
-                const recipe = (0, migration_1.readDeploymentRecipeJsonFile)(newestFilePath);
+                const recipe = (0, migration_1.readDeploymentMigrationFile)(newestFilePath);
                 // todo: handle multiple cell recipes?
                 const firstCell = recipe.cellRecipes[0];
                 const isDepCode = recipe.depGroupRecipes.length > 0;

package/dist/sdk/ckb.d.ts

@@ -0,0 +1,37 @@
+import { ccc, Script } from '@ckb-ccc/core';
+import { Network, HexNumber, HexString } from '../type/base';
+export declare class CKBProps {
+    network?: Network;
+    feeRate?: number;
+    isEnableProxyRpc?: boolean;
+}
+export interface DeploymentResult {
+    txHash: HexString;
+    tx: ccc.Transaction;
+    scriptOutputCellIndex: number;
+    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, 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

@@ -0,0 +1,254 @@
+"use strict";
+// this is a rewrite for util/ckb.ts
+// to replace lumos with ccc
+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.CKB = exports.CKBProps = void 0;
+const core_1 = require("@ckb-ccc/core");
+const validator_1 = require("../util/validator");
+const network_1 = require("./network");
+const private_1 = require("../scripts/private");
+const migration_1 = require("../deploy/migration");
+const base_1 = require("../type/base");
+class CKBProps {
+}
+exports.CKBProps = CKBProps;
+class CKB {
+    constructor({ network = base_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'
+                    ? new core_1.ccc.ClientPublicMainnet({ url: network_1.networks.mainnet.proxy_rpc_url })
+                    : network === 'testnet'
+                        ? new core_1.ccc.ClientPublicTestnet({ url: network_1.networks.testnet.proxy_rpc_url })
+                        : new core_1.ccc.ClientPublicTestnet({
+                            url: network_1.networks.devnet.proxy_rpc_url,
+                            scripts: (0, private_1.buildCCCDevnetKnownScripts)(),
+                        });
+        }
+        else {
+            this.client =
+                network === 'mainnet'
+                    ? new core_1.ccc.ClientPublicMainnet()
+                    : network === 'testnet'
+                        ? new core_1.ccc.ClientPublicTestnet()
+                        : new core_1.ccc.ClientPublicTestnet({
+                            url: network_1.networks.devnet.rpc_url,
+                            scripts: (0, private_1.buildCCCDevnetKnownScripts)(),
+                        });
+        }
+    }
+    buildSigner(privateKey) {
+        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* () {
+                const res = yield this.client.getTransactionNoCache(txHash);
+                if (res && res.status === 'committed') {
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            });
+            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);
+            const signerSecp256k1Address = yield signer.getAddressObjSecp256k1();
+            const tx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        lock: signerSecp256k1Address.script,
+                    },
+                ],
+                outputsData: [scriptBinBytes],
+            });
+            yield tx.completeInputsByCapacity(signer);
+            yield tx.completeFeeBy(signer, this.feeRate);
+            const txHash = yield signer.sendTransaction(tx);
+            return { txHash, tx, scriptOutputCellIndex: 0, isTypeId: false };
+        });
+    }
+    deployNewTypeIDScript(scriptBinBytes, privateKey) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signer = this.buildSigner(privateKey);
+            const signerSecp256k1Address = yield signer.getAddressObjSecp256k1();
+            const typeIdTx = core_1.ccc.Transaction.from({
+                outputs: [
+                    {
+                        lock: signerSecp256k1Address.script,
+                        type: yield core_1.ccc.Script.fromKnownScript(this.client, core_1.ccc.KnownScript.TypeId, '00'.repeat(32)),
+                    },
+                ],
+                outputsData: [scriptBinBytes],
+            });
+            yield typeIdTx.completeInputsByCapacity(signer);
+            if (!typeIdTx.outputs[0].type) {
+                throw new Error('Unexpected disappeared output');
+            }
+            typeIdTx.outputs[0].type.args = core_1.ccc.hashTypeId(typeIdTx.inputs[0], 0);
+            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 };
+        });
+    }
+    upgradeTypeIdScript(scriptName, newScriptBinBytes, privateKey) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const deploymentReceipt = migration_1.Migration.find(scriptName, this.network);
+            if (deploymentReceipt == null)
+                throw new Error("no migration file, can't be updated.");
+            const outpoint = {
+                txHash: deploymentReceipt.cellRecipes[0].txHash,
+                index: deploymentReceipt.cellRecipes[0].index,
+            };
+            const typeId = deploymentReceipt.cellRecipes[0].typeId;
+            if (typeId == null)
+                throw new Error("type id in migration file is null, can't be updated.");
+            const cell = yield this.client.getCell(outpoint);
+            if (cell == null) {
+                throw new Error('type id cell not found!');
+            }
+            const typeIdArgs = (_a = cell.cellOutput.type) === null || _a === void 0 ? void 0 : _a.args;
+            if (typeIdArgs == null) {
+                throw new Error("type id args is null, can't be updated");
+            }
+            const typeIdFromLiveCell = core_1.ccc.Script.from(cell.cellOutput.type).hash();
+            if (typeId !== typeIdFromLiveCell) {
+                throw new Error(`type id not matched! migration file type id: ${typeId}, live cell type id: ${typeIdFromLiveCell}`);
+            }
+            const cellInput = core_1.ccc.CellInput.from({ previousOutput: cell.outPoint, since: 0 });
+            const signer = this.buildSigner(privateKey);
+            const signerSecp256k1Address = yield signer.getAddressObjSecp256k1();
+            const typeIdTx = core_1.ccc.Transaction.from({
+                inputs: [cellInput],
+                outputs: [
+                    {
+                        lock: signerSecp256k1Address.script,
+                        type: yield core_1.ccc.Script.fromKnownScript(this.client, core_1.ccc.KnownScript.TypeId, '00'.repeat(32)),
+                    },
+                ],
+                outputsData: [newScriptBinBytes],
+            });
+            yield typeIdTx.completeInputsByCapacity(signer);
+            if (!typeIdTx.outputs[0].type) {
+                throw new Error('Unexpected disappeared output');
+            }
+            typeIdTx.outputs[0].type.args = typeIdArgs;
+            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 };
+        });
+    }
+}
+exports.CKB = CKB;
+function waitFor(query, timeout, interval) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const startTime = Date.now();
+        while (true) {
+            if (Date.now() - startTime > timeout) {
+                throw new Error('Operation timed out');
+            }
+            try {
+                const result = yield query();
+                if (result)
+                    break;
+            }
+            catch (error) {
+                console.debug(error.message);
+            }
+            yield new Promise((resolve) => setTimeout(resolve, interval));
+        }
+    });
+}

package/dist/sdk/network.d.ts

@@ -0,0 +1,17 @@
+export declare const networks: {
+    devnet: {
+        addr_prefix: string;
+        rpc_url: string;
+        proxy_rpc_url: string;
+    };
+    testnet: {
+        addr_prefix: string;
+        rpc_url: string;
+        proxy_rpc_url: string;
+    };
+    mainnet: {
+        addr_prefix: string;
+        rpc_url: string;
+        proxy_rpc_url: string;
+    };
+};

package/dist/sdk/network.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.networks = void 0;
+const setting_1 = require("../cfg/setting");
+const config = (0, setting_1.readSettings)();
+exports.networks = {
+    devnet: {
+        addr_prefix: 'ckt',
+        rpc_url: config.devnet.rpcUrl,
+        proxy_rpc_url: `http://127.0.0.1:${config.rpc.proxyPort}`,
+    },
+    testnet: {
+        addr_prefix: 'ckt',
+        rpc_url: config.testnet.rpcUrl,
+        proxy_rpc_url: `http://127.0.0.1:${config.rpc.proxyPort}`,
+    },
+    mainnet: {
+        addr_prefix: 'ckb',
+        rpc_url: config.mainnet.rpcUrl,
+        proxy_rpc_url: `http://127.0.0.1:${config.rpc.proxyPort}`,
+    },
+};

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/tools/rpc-proxy.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import http from 'http';
-import { Network } from '../util/type';
+import { Network } from '../type/base';
 export declare function createRPCProxy(network: Network, targetRpcUrl: string, port: number): {
     server: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     network: Network;

package/dist/tools/rpc-proxy.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRPCProxy = void 0;
 const http_proxy_1 = __importDefault(require("http-proxy"));
 const http_1 = __importDefault(require("http"));
-const type_1 = require("../util/type");
+const base_1 = require("../type/base");
 const fs_1 = __importDefault(require("fs"));
 const setting_1 = require("../cfg/setting");
 const path_1 = __importDefault(require("path"));
@@ -38,7 +38,7 @@ function createRPCProxy(network, targetRpcUrl, port) {
                     if (method === 'send_transaction') {
                         const tx = params[0];
                         // todo: record tx
-                        if (network === type_1.Network.devnet) {
+                        if (network === base_1.Network.devnet) {
                             const cccTx = cccA.JsonRpcTransformers.transactionTo(tx);
                             const txHash = cccTx.hash();
                             const settings = (0, setting_1.readSettings)();

package/dist/{util/type.d.ts → type/base.d.ts}

@@ -7,3 +7,5 @@ export interface NetworkOption {
     network: Network;
 }
 export type H256 = string;
+export type HexString = string;
+export type HexNumber = string;

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/dist/util/validator.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidVersion = exports.validateNetworkOpt = exports.isValidNetworkString = exports.validateExecDappEnvironment = exports.validateTypescriptWorkspace = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
-const type_1 = require("./type");
+const base_1 = require("../type/base");
 function validateTypescriptWorkspace() {
     const cwd = process.cwd();
     // Check if package.json exists
@@ -50,7 +50,7 @@ function validateNetworkOpt(network) {
     if (!isValidNetworkString(network)) {
         throw new Error('invalid network option, ' + network);
     }
-    if (network === type_1.Network.mainnet) {
+    if (network === base_1.Network.mainnet) {
         console.log('Mainnet not support yet. Please use CKB-CLI to operate on mainnet for better security. Check https://github.com/nervosnetwork/ckb-cli');
         process.exit(1);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.3.0-rc3",
+  "version": "0.3.0-rc5",
   "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",
@@ -59,17 +60,17 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "@ckb-ccc/core": "^0.0.11-alpha.3",
-    "@ckb-lumos/lumos": "0.23.0",
+    "@ckb-ccc/core": "^0.0.16-alpha.3",
     "@iarna/toml": "^2.2.5",
     "@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 {};