@offckb/cli 0.3.0-rc3 → 0.3.0-rc4

package/README.md

@@ -212,6 +212,12 @@ To deploy the script, cd into the frontend folder and run:
 cd frontend && offckb deploy --network <devnet/testnet>
 ```
 
+Pass `--type-id` option if you want Scripts to be upgradable
+
+```sh
+cd frontend && offckb deploy --type-id --network <devnet/testnet>
+```
+
 Once the deployment is done, you can use the following command to check the deployed scripts:
 
 ```sh

package/dist/cli.js

@@ -123,6 +123,7 @@ program
     .description('Deploy contracts to different networks, only supports devnet and testnet')
     .option('--network <network>', 'Specify the network to deploy to', 'devnet')
     .option('--target <target>', 'Specify the relative bin target folder to deploy to')
+    .option('-t, --type-id', 'Specify if use upgradable type id to deploy the script')
     .option('--privkey <privkey>', 'Specify the private key to deploy scripts')
     .action((options) => (0, deploy_1.deploy)(options));
 program

package/dist/cmd/deploy.d.ts

@@ -2,5 +2,6 @@ import { NetworkOption } from '../util/type';
 export interface DeployOptions extends NetworkOption {
     target: string | null | undefined;
     privkey?: string | null;
+    typeId?: boolean;
 }
 export declare function deploy(opt?: DeployOptions): Promise<void>;

package/dist/cmd/deploy.js

@@ -13,36 +13,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deploy = void 0;
-const lumos_1 = require("@ckb-lumos/lumos");
-const fs_1 = __importDefault(require("fs"));
 const type_1 = require("../util/type");
 const path_1 = __importDefault(require("path"));
-const ckb_1 = require("../util/ckb");
 const account_1 = require("../cfg/account");
-const fs_2 = require("../util/fs");
+const fs_1 = require("../util/fs");
 const validator_1 = require("../util/validator");
-const toml_1 = require("../deploy/toml");
-const migration_1 = require("../deploy/migration");
-const utils_1 = require("@ckb-lumos/lumos/utils");
-const gen_1 = require("../scripts/gen");
-const offckb_config_1 = require("../template/offckb-config");
-function deploy(opt = { network: type_1.Network.devnet, target: null }) {
+const deploy_1 = require("../deploy");
+const ckb_1 = require("../sdk/ckb");
+function deploy(opt = { network: type_1.Network.devnet, typeId: false, target: null }) {
+    var _a;
     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 ckb = new ckb_1.CKB({ network });
         // we use deployerAccount to deploy contract by default
         const privateKey = opt.privkey || account_1.deployerAccount.privkey;
-        const lumosConfig = ckb.getLumosConfig();
-        const from = ckb_1.CKB.generateAccountFromPrivateKey(privateKey, lumosConfig);
+        const enableTypeId = (_a = opt.typeId) !== null && _a !== void 0 ? _a : false;
         const targetFolder = opt.target;
         if (targetFolder) {
-            const binFolder = (0, fs_2.isAbsolutePath)(targetFolder) ? targetFolder : path_1.default.resolve(process.cwd(), targetFolder);
-            const bins = (0, fs_2.listBinaryFilesInFolder)(binFolder);
+            const binFolder = (0, fs_1.isAbsolutePath)(targetFolder) ? targetFolder : path_1.default.resolve(process.cwd(), targetFolder);
+            const bins = (0, fs_1.listBinaryFilesInFolder)(binFolder);
             const binPaths = bins.map((bin) => path_1.default.resolve(binFolder, bin));
-            const results = yield deployBinaries(binPaths, from, ckb);
+            const results = yield (0, deploy_1.deployBinaries)(binPaths, privateKey, enableTypeId, ckb);
             // record the deployed contract infos
-            recordDeployResult(results, network, false); // we don't update my-scripts.json since we don't know where the file is
+            (0, deploy_1.recordDeployResult)(results, network, false); // we don't update my-scripts.json since we don't know where the file is
             return;
         }
         // check if target workspace is valid
@@ -53,105 +47,10 @@ function deploy(opt = { network: type_1.Network.devnet, target: null }) {
             return console.debug('Not a valid offCKB dapp workspace.');
         }
         // read contract bin folder
-        const bins = getToDeployBinsPath();
-        const results = yield deployBinaries(bins, from, ckb);
+        const bins = (0, deploy_1.getToDeployBinsPath)();
+        const results = yield (0, deploy_1.deployBinaries)(bins, privateKey, enableTypeId, ckb);
         // record the deployed contract infos
-        recordDeployResult(results, network);
+        (0, deploy_1.recordDeployResult)(results, network);
     });
 }
 exports.deploy = deploy;
-function getToDeployBinsPath() {
-    const userOffCKBConfigPath = path_1.default.resolve(process.cwd(), 'offckb.config.ts');
-    const fileContent = fs_1.default.readFileSync(userOffCKBConfigPath, 'utf-8');
-    const match = fileContent.match(/contractBinFolder:\s*['"]([^'"]+)['"]/);
-    if (match && match[1]) {
-        const contractBinFolderValue = match[1];
-        const binFolderPath = (0, fs_2.isAbsolutePath)(contractBinFolderValue)
-            ? contractBinFolderValue
-            : path_1.default.resolve(process.cwd(), contractBinFolderValue);
-        const bins = (0, fs_2.listBinaryFilesInFolder)(binFolderPath);
-        return bins.map((bin) => path_1.default.resolve(binFolderPath, bin));
-    }
-    else {
-        console.log('contractBinFolder value not found in offckb.config.ts');
-        return [];
-    }
-}
-function recordDeployResult(results, network, updateMyScriptsJsonFile = true) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (results.length === 0) {
-            return;
-        }
-        for (const result of results) {
-            (0, toml_1.generateDeploymentToml)(result.deploymentOptions, network);
-            (0, migration_1.generateDeploymentRecipeJsonFile)(result.deploymentOptions.name, result.deploymentRecipe, network);
-        }
-        // update my-scripts.json
-        if (updateMyScriptsJsonFile) {
-            const userOffCKBConfigPath = path_1.default.resolve(process.cwd(), 'offckb.config.ts');
-            const folder = offckb_config_1.OffCKBConfigFile.readContractInfoFolder(userOffCKBConfigPath);
-            if (folder) {
-                const myScriptsFilePath = path_1.default.resolve(folder, 'my-scripts.json');
-                (0, gen_1.genMyScriptsJsonFile)(myScriptsFilePath);
-            }
-        }
-        console.log('done.');
-    });
-}
-function deployBinaries(binPaths, from, ckb) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (binPaths.length === 0) {
-            console.log('No binary to deploy.');
-        }
-        const results = [];
-        for (const bin of binPaths) {
-            const result = yield deployBinary(bin, from, ckb);
-            results.push(result);
-        }
-        return results;
-    });
-}
-function deployBinary(binPath, from, ckb) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const bin = yield (0, fs_2.readFileToUint8Array)(binPath);
-        const contractName = path_1.default.basename(binPath);
-        const result = yield lumos_1.commons.deploy.generateDeployWithTypeIdTx({
-            cellProvider: ckb.indexer,
-            fromInfo: from.address,
-            scriptBinary: bin,
-            config: ckb.getLumosConfig(),
-        });
-        // send deploy tx
-        let txSkeleton = result.txSkeleton;
-        txSkeleton = lumos_1.commons.common.prepareSigningEntries(txSkeleton);
-        const message = txSkeleton.get('signingEntries').get(0).message;
-        const Sig = lumos_1.hd.key.signRecoverable(message, from.privKey);
-        const tx = lumos_1.helpers.sealTransaction(txSkeleton, [Sig]);
-        const res = yield ckb.rpc.sendTransaction(tx, 'passthrough');
-        console.log(`contract ${contractName} deployed, tx hash:`, res);
-        console.log('wait 4 blocks..');
-        yield ckb.indexer.waitForSync(-4); // why negative 4? a bug in ckb-lumos
-        // todo: handle multiple cell recipes?
-        return {
-            deploymentOptions: {
-                name: contractName,
-                binFilePath: binPath,
-                enableTypeId: true,
-                lockScript: tx.outputs[+result.scriptConfig.INDEX].lock,
-            },
-            deploymentRecipe: {
-                cellRecipes: [
-                    {
-                        name: contractName,
-                        txHash: result.scriptConfig.TX_HASH,
-                        index: result.scriptConfig.INDEX,
-                        occupiedCapacity: '0x' + BigInt(tx.outputsData[+result.scriptConfig.INDEX].slice(2).length / 2).toString(16),
-                        dataHash: (0, utils_1.ckbHash)(tx.outputsData[+result.scriptConfig.INDEX]),
-                        typeId: (0, utils_1.computeScriptHash)(result.typeId),
-                    },
-                ],
-                depGroupRecipes: [],
-            },
-        };
-    });
-}

package/dist/deploy/index.d.ts

@@ -0,0 +1,18 @@
+import { DeploymentOptions } from '../deploy/toml';
+import { DeploymentRecipe } from '../deploy/migration';
+import { HexString } from '@ckb-lumos/lumos';
+import { Network } from '../util/type';
+import { CKB } from '../sdk/ckb';
+export type DeployBinaryReturnType = ReturnType<typeof deployBinary>;
+export type UnwrapPromise<T> = T extends Promise<infer U> ? U : T;
+export type DeployedInterfaceType = UnwrapPromise<DeployBinaryReturnType>;
+export declare function getToDeployBinsPath(): string[];
+export declare function recordDeployResult(results: DeployedInterfaceType[], network: Network, isUpdateMyScriptsJsonFile?: boolean): Promise<void>;
+export declare function deployBinaries(binPaths: string[], privateKey: HexString, enableTypeId: boolean, ckb: CKB): Promise<{
+    deploymentRecipe: DeploymentRecipe;
+    deploymentOptions: DeploymentOptions;
+}[]>;
+export declare function deployBinary(binPath: string, privateKey: HexString, enableTypeId: boolean, ckb: CKB): Promise<{
+    deploymentRecipe: DeploymentRecipe;
+    deploymentOptions: DeploymentOptions;
+}>;

package/dist/deploy/index.js

@@ -0,0 +1,126 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployBinary = exports.deployBinaries = exports.recordDeployResult = exports.getToDeployBinsPath = void 0;
+const toml_1 = require("../deploy/toml");
+const migration_1 = require("../deploy/migration");
+const utils_1 = require("@ckb-lumos/lumos/utils");
+const gen_1 = require("../scripts/gen");
+const offckb_config_1 = require("../template/offckb-config");
+const fs_1 = require("../util/fs");
+const path_1 = __importDefault(require("path"));
+const fs_2 = __importDefault(require("fs"));
+function getToDeployBinsPath() {
+    const userOffCKBConfigPath = path_1.default.resolve(process.cwd(), 'offckb.config.ts');
+    const fileContent = fs_2.default.readFileSync(userOffCKBConfigPath, 'utf-8');
+    const match = fileContent.match(/contractBinFolder:\s*['"]([^'"]+)['"]/);
+    if (match && match[1]) {
+        const contractBinFolderValue = match[1];
+        const binFolderPath = (0, fs_1.isAbsolutePath)(contractBinFolderValue)
+            ? contractBinFolderValue
+            : path_1.default.resolve(process.cwd(), contractBinFolderValue);
+        const bins = (0, fs_1.listBinaryFilesInFolder)(binFolderPath);
+        return bins.map((bin) => path_1.default.resolve(binFolderPath, bin));
+    }
+    else {
+        console.log('contractBinFolder value not found in offckb.config.ts');
+        return [];
+    }
+}
+exports.getToDeployBinsPath = getToDeployBinsPath;
+function recordDeployResult(results, network, isUpdateMyScriptsJsonFile = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (results.length === 0) {
+            return;
+        }
+        for (const result of results) {
+            (0, toml_1.generateDeploymentToml)(result.deploymentOptions, network);
+            (0, migration_1.generateDeploymentMigrationFile)(result.deploymentOptions.name, result.deploymentRecipe, network);
+        }
+        // update my-scripts.json
+        if (isUpdateMyScriptsJsonFile) {
+            const userOffCKBConfigPath = path_1.default.resolve(process.cwd(), 'offckb.config.ts');
+            const folder = offckb_config_1.OffCKBConfigFile.readContractInfoFolder(userOffCKBConfigPath);
+            if (folder) {
+                const myScriptsFilePath = path_1.default.resolve(folder, 'my-scripts.json');
+                (0, gen_1.genMyScriptsJsonFile)(myScriptsFilePath);
+            }
+        }
+        console.log('done.');
+    });
+}
+exports.recordDeployResult = recordDeployResult;
+function deployBinaries(binPaths, privateKey, enableTypeId, ckb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (binPaths.length === 0) {
+            console.log('No binary to deploy.');
+        }
+        const results = [];
+        for (const bin of binPaths) {
+            const result = yield deployBinary(bin, privateKey, enableTypeId, ckb);
+            results.push(result);
+        }
+        return results;
+    });
+}
+exports.deployBinaries = deployBinaries;
+function deployBinary(binPath, privateKey, enableTypeId, ckb) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const bin = yield (0, fs_1.readFileToUint8Array)(binPath);
+        const contractName = path_1.default.basename(binPath);
+        const result = !enableTypeId
+            ? yield ckb.deployScript(bin, privateKey)
+            : migration_1.Migration.isDeployedWithTypeId(contractName, ckb.network)
+                ? yield ckb.upgradeTypeIdScript(contractName, bin, privateKey)
+                : yield ckb.deployNewTypeIDScript(bin, privateKey);
+        console.log(`contract ${contractName} deployed, tx hash:`, result.txHash);
+        console.log('wait for tx confirmed on-chain...');
+        yield ckb.waitForTxConfirm(result.txHash);
+        console.log('tx committed.');
+        const txHash = result.txHash;
+        const typeIdScript = result.typeId;
+        const index = result.scriptOutputCellIndex;
+        const tx = result.tx;
+        const dataByteLen = BigInt(tx.outputsData[+index].slice(2).length / 2);
+        const dataShannonLen = dataByteLen * BigInt('100000000');
+        const occupiedCapacity = '0x' + dataShannonLen.toString(16);
+        if (enableTypeId && typeIdScript == null) {
+            throw new Error('type id script is null while enableTypeId is true.');
+        }
+        const typeIdScriptHash = enableTypeId ? (0, utils_1.computeScriptHash)(typeIdScript) : undefined;
+        // todo: handle multiple cell recipes?
+        return {
+            deploymentOptions: {
+                name: contractName,
+                binFilePath: binPath,
+                enableTypeId: enableTypeId,
+                lockScript: tx.outputs[+index].lock,
+            },
+            deploymentRecipe: {
+                cellRecipes: [
+                    {
+                        name: contractName,
+                        txHash,
+                        index: '0x' + index.toString(16),
+                        occupiedCapacity,
+                        dataHash: (0, utils_1.ckbHash)(tx.outputsData[+index]),
+                        typeId: typeIdScriptHash,
+                    },
+                ],
+                depGroupRecipes: [],
+            },
+        };
+    });
+}
+exports.deployBinary = deployBinary;

package/dist/deploy/migration.d.ts

@@ -19,27 +19,32 @@ export interface DeploymentRecipe {
     cellRecipes: CellRecipe[];
     depGroupRecipes: DepGroupRecipe[];
 }
-export interface DeploymentRecipeJson {
+export interface MigrationJson {
     cell_recipes: {
         name: string;
         tx_hash: string;
-        index: HexNumber;
-        occupied_capacity: HexNumber;
+        index: number;
+        occupied_capacity: number;
         data_hash: string;
         type_id?: string;
     }[];
     dep_group_recipes: {
         name: string;
         tx_hash: string;
-        index: HexNumber;
+        index: number;
         data_hash: string;
-        occupied_capacity: HexNumber;
+        occupied_capacity: number;
     }[];
 }
-export declare function generateDeploymentRecipeJsonFile(name: string, deploymentRecipe: DeploymentRecipe, network?: Network): void;
-export declare function readDeploymentRecipeJsonFile(filePath: string): DeploymentRecipe;
+export declare class Migration {
+    static find(scriptName: string, network?: Network): DeploymentRecipe | null;
+    static isDeployed(scriptName: string, network?: Network): boolean;
+    static isDeployedWithTypeId(scriptName: string, network?: Network): boolean;
+}
+export declare function generateDeploymentMigrationFile(name: string, deploymentRecipe: DeploymentRecipe, network?: Network): void;
+export declare function readDeploymentMigrationFile(filePath: string): DeploymentRecipe;
 export declare function getFormattedMigrationDate(): string;
 export declare function getMigrationFolderPath(scriptName: string, network: Network): string;
-export declare function getNewestMigrationFile(folderPath: string): string | undefined;
-export declare function deploymentRecipeToJson(recipe: DeploymentRecipe): DeploymentRecipeJson;
-export declare function deploymentRecipeFromJson(json: DeploymentRecipeJson): DeploymentRecipe;
+export declare function getNewestMigrationFile(folderPath: string): string | null;
+export declare function deploymentRecipeToJson(recipe: DeploymentRecipe): MigrationJson;
+export declare function deploymentRecipeFromJson(json: MigrationJson): DeploymentRecipe;

package/dist/deploy/migration.js

@@ -26,12 +26,38 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deploymentRecipeFromJson = exports.deploymentRecipeToJson = exports.getNewestMigrationFile = exports.getMigrationFolderPath = exports.getFormattedMigrationDate = exports.readDeploymentRecipeJsonFile = exports.generateDeploymentRecipeJsonFile = void 0;
+exports.deploymentRecipeFromJson = exports.deploymentRecipeToJson = exports.getNewestMigrationFile = exports.getMigrationFolderPath = exports.getFormattedMigrationDate = exports.readDeploymentMigrationFile = exports.generateDeploymentMigrationFile = exports.Migration = void 0;
 const type_1 = require("../util/type");
 const path_1 = __importStar(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const util_1 = require("./util");
-function generateDeploymentRecipeJsonFile(name, deploymentRecipe, network = type_1.Network.devnet) {
+class Migration {
+    static find(scriptName, network = type_1.Network.devnet) {
+        const filePath = getMigrationFolderPath(scriptName, network);
+        const migrationFile = getNewestMigrationFile(filePath);
+        if (migrationFile == null)
+            return null;
+        return readDeploymentMigrationFile(migrationFile);
+    }
+    static isDeployed(scriptName, network = type_1.Network.devnet) {
+        const deploymentReceipt = Migration.find(scriptName, network);
+        if (deploymentReceipt == null)
+            return false;
+        return true;
+    }
+    static isDeployedWithTypeId(scriptName, network = type_1.Network.devnet) {
+        const isDeployed = this.isDeployed(scriptName, network);
+        if (isDeployed === false)
+            return false;
+        const deploymentReceipt = Migration.find(scriptName, network);
+        const typeId = deploymentReceipt.cellRecipes[0].typeId;
+        if (typeId == null)
+            return false;
+        return true;
+    }
+}
+exports.Migration = Migration;
+function generateDeploymentMigrationFile(name, deploymentRecipe, network = type_1.Network.devnet) {
     const cellRecipes = deploymentRecipe.cellRecipes;
     const depGroupRecipes = deploymentRecipe.depGroupRecipes;
     const jsonString = JSON.stringify(deploymentRecipeToJson({ cellRecipes, depGroupRecipes }), null, 2);
@@ -44,13 +70,13 @@ function generateDeploymentRecipeJsonFile(name, deploymentRecipe, network = type
         console.log(`${name} migration json file ${outputFilePath} generated successfully.`);
     }
 }
-exports.generateDeploymentRecipeJsonFile = generateDeploymentRecipeJsonFile;
-function readDeploymentRecipeJsonFile(filePath) {
+exports.generateDeploymentMigrationFile = generateDeploymentMigrationFile;
+function readDeploymentMigrationFile(filePath) {
     const jsonString = fs_1.default.readFileSync(filePath, 'utf-8');
     const data = JSON.parse(jsonString);
     return deploymentRecipeFromJson(data);
 }
-exports.readDeploymentRecipeJsonFile = readDeploymentRecipeJsonFile;
+exports.readDeploymentMigrationFile = readDeploymentMigrationFile;
 function getFormattedMigrationDate() {
     const now = new Date();
     const year = now.getFullYear();
@@ -68,6 +94,9 @@ function getMigrationFolderPath(scriptName, network) {
 }
 exports.getMigrationFolderPath = getMigrationFolderPath;
 function getNewestMigrationFile(folderPath) {
+    if (!fs_1.default.existsSync(folderPath) || !fs_1.default.lstatSync(folderPath).isDirectory()) {
+        return null;
+    }
     const files = fs_1.default
         .readdirSync(folderPath)
         .filter((file) => file.endsWith('.json')) // Ensure only JSON files are considered
@@ -78,28 +107,36 @@ function getNewestMigrationFile(folderPath) {
         return timestampA.localeCompare(timestampB);
     });
     // Return the full path of the newest file (last in sorted array) or undefined if no files
-    return files.length > 0 ? path_1.default.join(folderPath, files[files.length - 1]) : undefined;
+    return files.length > 0 ? path_1.default.join(folderPath, files[files.length - 1]) : null;
 }
 exports.getNewestMigrationFile = getNewestMigrationFile;
 function deploymentRecipeToJson(recipe) {
     return {
         cell_recipes: recipe.cellRecipes.map((val) => {
+            if (BigInt(val.occupiedCapacity) > BigInt(Number.MAX_SAFE_INTEGER)) {
+                // CKB blocksize limit is 500k, so it should be impossible to have a cell occupied data larger than Number.MAX_SAFE_INTEGER which is 9007,1992,5474,0991
+                console.error(`invalid occupiedCapacity: ${val.occupiedCapacity}, the cell_recipes json might be incorrect for cell outpoint ${val.txHash}:${+val.index}`);
+            }
             return {
                 name: val.name,
                 tx_hash: val.txHash,
-                index: val.index,
-                occupied_capacity: val.occupiedCapacity,
+                index: +val.index,
+                occupied_capacity: +BigInt(val.occupiedCapacity).toString(10),
                 data_hash: val.dataHash,
                 type_id: val.typeId,
             };
         }),
         dep_group_recipes: recipe.depGroupRecipes.map((val) => {
+            if (BigInt(val.occupiedCapacity) > BigInt(Number.MAX_SAFE_INTEGER)) {
+                // CKB blocksize limit is 500k, so it should be impossible to have a cell occupied data larger than Number.MAX_SAFE_INTEGER which is 9007,1992,5474,0991
+                console.error(`invalid occupiedCapacity: ${val.occupiedCapacity}, the dep_group_recipes json might be incorrect for cell outpoint ${val.txHash}:${+val.index}`);
+            }
             return {
                 name: val.name,
                 tx_hash: val.txHash,
-                index: val.index,
+                index: +val.index,
                 data_hash: val.dataHash,
-                occupied_capacity: val.occupiedCapacity,
+                occupied_capacity: +BigInt(val.occupiedCapacity).toString(10),
             };
         }),
     };
@@ -111,8 +148,8 @@ function deploymentRecipeFromJson(json) {
             return {
                 name: val.name,
                 txHash: val.tx_hash,
-                index: val.index,
-                occupiedCapacity: val.occupied_capacity,
+                index: '0x' + val.index.toString(16),
+                occupiedCapacity: '0x' + val.occupied_capacity.toString(16),
                 dataHash: val.data_hash,
                 typeId: val.type_id,
             };
@@ -121,9 +158,9 @@ function deploymentRecipeFromJson(json) {
             return {
                 name: val.name,
                 txHash: val.tx_hash,
-                index: val.index,
+                index: '0x' + val.index.toString(16),
                 dataHash: val.data_hash,
-                occupiedCapacity: val.occupied_capacity,
+                occupiedCapacity: '0x' + val.occupied_capacity.toString(16),
             };
         }),
     };

package/dist/deploy/toml.d.ts

@@ -10,7 +10,7 @@ export interface DeploymentOptions {
 export interface DeploymentToml {
     cells: {
         name: string;
-        enable_type_id: 'true' | 'false';
+        enable_type_id: boolean;
         location: {
             file: string;
         };

package/dist/deploy/toml.js

@@ -13,7 +13,7 @@ function generateDeploymentToml(options, network) {
         cells: [
             {
                 name: options.name,
-                enable_type_id: options.enableTypeId ? 'true' : 'false',
+                enable_type_id: options.enableTypeId,
                 location: {
                     file: options.binFilePath,
                 },
@@ -44,7 +44,7 @@ function readDeploymentToml(scriptName, network) {
         cells: [
             {
                 name: data.cells[0].name,
-                enableTypeId: data.cells[0].enable_type_id === 'true' ? true : false,
+                enableTypeId: data.cells[0].enable_type_id,
                 location: {
                     file: data.cells[0].location.file,
                 },

package/dist/scripts/private.d.ts

@@ -0,0 +1,4 @@
+import { ccc } from '@ckb-ccc/core';
+export declare function buildCCCDevnetKnownScripts(): Record<ccc.KnownScript, Pick<ccc.Script, "codeHash" | "hashType"> & {
+    cellDeps: ccc.CellDepInfoLike[];
+}>;

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.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,24 @@
+import { ccc, Script } from '@ckb-ccc/core';
+import { Network } from '../util/type';
+import { HexString } from '@ckb-lumos/lumos';
+export declare class CKBProps {
+    network?: Network;
+    isEnableProxyRpc?: boolean;
+}
+export interface DeploymentResult {
+    txHash: HexString;
+    tx: ccc.Transaction;
+    scriptOutputCellIndex: number;
+    isTypeId: boolean;
+    typeId?: Script;
+}
+export declare class CKB {
+    network: Network;
+    private client;
+    constructor({ network, isEnableProxyRpc }: CKBProps);
+    private buildSigner;
+    waitForTxConfirm(txHash: HexString, timeout?: number): Promise<void>;
+    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,180 @@
+"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 type_1 = require("../util/type");
+const validator_1 = require("../util/validator");
+const network_1 = require("./network");
+const private_1 = require("../scripts/private");
+const migration_1 = require("../deploy/migration");
+class CKBProps {
+}
+exports.CKBProps = CKBProps;
+class CKB {
+    constructor({ network = type_1.Network.devnet, isEnableProxyRpc = false }) {
+        if (!(0, validator_1.isValidNetworkString)(network)) {
+            throw new Error('invalid network option');
+        }
+        this.network = network;
+        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;
+    }
+    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);
+        });
+    }
+    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, 1000);
+            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, 1000);
+            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, 1000);
+            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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@offckb/cli",
-  "version": "0.3.0-rc3",
+  "version": "0.3.0-rc4",
   "description": "ckb development network for your first try",
   "author": "CKB EcoFund",
   "license": "MIT",
@@ -59,7 +59,7 @@
     "typescript": "^5.3.3"
   },
   "dependencies": {
-    "@ckb-ccc/core": "^0.0.11-alpha.3",
+    "@ckb-ccc/core": "^0.0.16-alpha.3",
     "@ckb-lumos/lumos": "0.23.0",
     "@iarna/toml": "^2.2.5",
     "@inquirer/prompts": "^4.1.0",