TITLE: Implementing Unique Type Script Logic in C
DESCRIPTION: This C code implements the logic for a unique type script on CKB. It checks that there is exactly one input cell and zero output cells with the current type script. It then verifies if the script's arguments match the OutPoint of the first input cell, ensuring uniqueness based on the transaction input. The script uses CKB syscalls like `ckb_load_cell`, `ckb_load_input`, and `ckb_load_script`, and verifies the script structure using MolReader.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-6.md#_snippet_0

LANGUAGE: C
CODE:
```
#include "blockchain.h"\n#include "ckb_syscalls.h"\n\n#define INPUT_SIZE 128\n#define SCRIPT_SIZE 32768\n\nint main() {\n  uint64_t len = 0;\n  int ret = ckb_load_cell(NULL, &len, 0, 1, CKB_SOURCE_GROUP_OUTPUT);\n  if (ret != CKB_INDEX_OUT_OF_BOUND) {\n    return -1;  /* 1 */\n  }\n\n  len = 0;\n  ret = ckb_load_cell(NULL, &len, 0, 0, CKB_SOURCE_GROUP_INPUT);\n  if (ret != CKB_INDEX_OUT_OF_BOUND) {\n    return 0;  /* 2 */\n  }\n\n  /* 3 */\n  unsigned char input[INPUT_SIZE];\n  uint64_t input_len = INPUT_SIZE;\n  ret = ckb_load_input(input, &input_len, 0, 0, CKB_SOURCE_INPUT);\n  if (ret != CKB_SUCCESS) {\n    return ret;\n  }\n  if (input_len > INPUT_SIZE) {\n    return -100;\n  }\n\n  unsigned char script[SCRIPT_SIZE];\n  len = SCRIPT_SIZE;\n  ret = ckb_load_script(script, &len, 0);\n  if (ret != CKB_SUCCESS) {\n    return ret;\n  }\n  if (len > SCRIPT_SIZE) {\n    return -101;\n  }\n  mol_seg_t script_seg;\n  script_seg.ptr = (uint8_t *)script;\n  script_seg.size = len;\n\n  if (MolReader_Script_verify(&script_seg, false) != MOL_OK) {\n    return -102;\n  }\n\n  mol_seg_t args_seg = MolReader_Script_get_args(&script_seg);\n  mol_seg_t args_bytes_seg = MolReader_Bytes_raw_bytes(&args_seg);\n\n  if ((input_len == args_bytes_seg.size) &&\n      (memcmp(args_bytes_seg.ptr, input, input_len) == 0)) {\n    /* 4 */\n    return 0;\n  }\n  return -103;\n}
```

----------------------------------------

TITLE: Building CKB Transaction with Lumos (Data Update) - JavaScript
DESCRIPTION: Updates the data field of the first output cell in a Lumos transaction skeleton, pays the fee, prepares signing entries, signs the transaction, and sends it to the RPC. It also calculates the code hash for the data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_15

LANGUAGE: JavaScript
CODE:
```
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
const duktapeTxHash = await rpc.sendTransaction(signedTx)
const duktapeCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
```

----------------------------------------

TITLE: Starting the Local CKB Devnet with OffCKB (Bash)
DESCRIPTION: Starts a local CKB development network (Devnet) using the offCKB CLI. This command makes the Devnet RPC endpoint available at `localhost:8114` for development and testing.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_5

LANGUAGE: bash
CODE:
```
offckb node
```

----------------------------------------

TITLE: Starting Local CKB Devnet Node (sh)
DESCRIPTION: Command to start a local CKB blockchain node using `offckb` for development and testing.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_11

LANGUAGE: sh
CODE:
```
offckb node
```

----------------------------------------

TITLE: Generating Account from Private Key (TypeScript)
DESCRIPTION: This function generates an account's public key and address from a given private key using the CCC SDK. It constructs a CKB standard Lock Script (SECP256K1 + BLAKE160) to derive the address. Requires the CCC SDK client (`cccClient`).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_1

LANGUAGE: TypeScript
CODE:
```
export const generateAccountFromPrivateKey = async (
  privKey: string
): Promise<Account> => {
  const signer = new ccc.SignerCkbPrivateKey(cccClient, privKey);
  const lock = await signer.getAddressObjSecp256k1();
  return {
    lockScript: lock.script,
    address: lock.toString(),
    pubKey: signer.publicKey,
  };
};
```

----------------------------------------

TITLE: Finalize and Sign Transaction (JavaScript)
DESCRIPTION: Calculates the transaction fee and prepares the signing entries for the transaction skeleton using Lumos common functions. This is a necessary step before signing the transaction, ensuring all parts of the transaction requiring signatures are identified and formatted correctly.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_10

LANGUAGE: js
CODE:
```
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
```

----------------------------------------

TITLE: Building and Sending CKB Transaction to Issue xUDT (TypeScript)
DESCRIPTION: This code snippet constructs a CKB transaction to issue an xUDT with a Type ID. It defines the transaction structure including inputs and outputs, adds required cell dependencies for relevant scripts (OutputTypeProxyLock, XUdt, UniqueType), completes the transaction by filling inputs based on capacity and calculating the fee, updates the Type ID argument based on the first input and output index, sends the transaction using a signer, and waits for the transaction to be committed on the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_14

LANGUAGE: TypeScript
CODE:
```
          ],
              outputs: [
                // Keep the Type ID cell
                typeIdCell.cellOutput,
                // Issued xUDT
                {
                  lock: script,
                  type: await ccc.Script.fromKnownScript(
                    signer.client,
                    ccc.KnownScript.XUdt,
                    outputTypeLock.hash()
                  ),
                },
                // xUDT Info
                {
                  lock: script,
                  type: await ccc.Script.fromKnownScript(
                    signer.client,
                    ccc.KnownScript.UniqueType,
                    "00".repeat(32)
                  ),
                },
              ],
              outputsData: [
                typeIdCell.outputData,
                ccc.numLeToBytes(amount, 16),
                tokenInfoToBytes(decimals, symbol, name),
              ],
            });
            await mintTx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.OutputTypeProxyLock,
              ccc.KnownScript.XUdt,
              ccc.KnownScript.UniqueType
            );
            await mintTx.completeInputsByCapacity(signer);
            if (!mintTx.outputs[2].type) {
              throw new Error("Unexpected disappeared output");
            }
            mintTx.outputs[2].type!.args = ccc.hexFrom(
              ccc.bytesFrom(ccc.hashTypeId(mintTx.inputs[0], 2)).slice(0, 20)
            );
            await mintTx.completeFeeBy(signer);
            const mintTxHash = await signer.sendTransaction(mintTx);
            log("Transaction sent:", explorerTransaction(mintTxHash));
            await signer.client.waitTransaction(mintTxHash);
            log("Transaction committed:", explorerTransaction(mintTxHash));
          }}
```

----------------------------------------

TITLE: Deploying CKB Script Binary with Lumos (Javascript)
DESCRIPTION: Javascript code using the Lumos SDK to deploy a compiled CKB script binary (`carrot_bug`) onto the CKB testnet. Reads the binary file, creates a transaction, sets the binary as cell data, signs, and sends the transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_2

LANGUAGE: Javascript
CODE:
```
const lumos = require("@ckb-lumos/lumos");
const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
lumos.config.initializeConfig(lumos.config.TESTNET);
const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6",
};
const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}

const data = fs.readFileSync("carrot_bug");
data.byteLength;
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"19900" + "00000000");
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const carrotTxHash = await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Validating Unique Type Script Instance in CKB (C)
DESCRIPTION: This C code snippet implements a Type Script that enforces uniqueness. It checks if the script is applied to exactly one input cell and verifies that the script's arguments match the OutPoint of the first input cell in the transaction. This mechanism prevents duplicate script instances.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/type-id.mdx#_snippet_0

LANGUAGE: c
CODE:
```
#include "blockchain.h"\n#include "ckb_syscalls.h"\n\n#define INPUT_SIZE 128\n#define SCRIPT_SIZE 32768\n\nint main() {\n  uint64_t len = 0;\n  int ret = ckb_load_cell(NULL, &len, 0, 1, CKB_SOURCE_GROUP_OUTPUT);\n  if (ret != CKB_INDEX_OUT_OF_BOUND) {\n    return -1;  /* 1 */\n  }\n\n  len = 0;\n  ret = ckb_load_cell(NULL, &len, 0, 0, CKB_SOURCE_GROUP_INPUT);\n  if (ret != CKB_INDEX_OUT_OF_BOUND) {\n    return 0;  /* 2 */\n  }\n\n  /* 3 */\n  unsigned char input[INPUT_SIZE];\n  uint64_t input_len = INPUT_SIZE;\n  ret = ckb_load_input(input, &input_len, 0, 0, CKB_SOURCE_INPUT);\n  if (ret != CKB_SUCCESS) {\n    return ret;\n  }\n  if (input_len > INPUT_SIZE) {\n    return -100;\n  }\n\n  unsigned char Script[SCRIPT_SIZE];\n  len = SCRIPT_SIZE;\n  ret = ckb_load_script(Script, &len, 0);\n  if (ret != CKB_SUCCESS) {\n    return ret;\n  }\n  if (len > SCRIPT_SIZE) {\n    return -101;\n  }\n  mol_seg_t script_seg;\n  script_seg.ptr = (uint8_t *)Script;\n  script_seg.size = len;\n\n  if (MolReader_Script_verify(&script_seg, false) != MOL_OK) {\n    return -102;\n  }\n\n  mol_seg_t args_seg = MolReader_Script_get_args(&script_seg);\n  mol_seg_t args_bytes_seg = MolReader_Bytes_raw_bytes(&args_seg);\n\n  if ((input_len == args_bytes_seg.size) &&\n      (memcmp(args_bytes_seg.ptr, input, input_len) == 0)) {\n    /* 4 */\n    return 0;\n  }\n  return -103;\n}
```

----------------------------------------

TITLE: Generate HD Wallet and Address - Lumos - TypeScript
DESCRIPTION: Demonstrates using Lumos's `hd` module to generate a mnemonic, derive an extended private key, extract the first receiving private key, and then derive the CKB address from that private key using the SECP256K1_BLAKE160 script template for the Aggron4 testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_5

LANGUAGE: TypeScript
CODE:
```
import { hd, config, helpers } from "@ckb-lumos/lumos";
const { mnemonic, ExtendedPrivateKey, AddressType } = hd;

// Use Testnet environment for this example
config.initializeConfig(config.predefined.AGGRON4);

// Generate a mnemonic and derive a private key
export const generateFirstHDPrivateKey = () => {
  const m = mnemonic.generateMnemonic();
  const seed = mnemonic.mnemonicToSeedSync(m);
  const extendedPrivKey = ExtendedPrivateKey.fromSeed(seed);
  return extendedPrivKey.privateKeyInfo(AddressType.Receving, 0).privateKey;
};

// Derive an address from the private key
const getAddressByPrivateKey = (privateKey: string) => {
  const args = hd.key.privateKeyToBlake160(privateKey);
  const template = config.predefined.AGGRON4.SCRIPTS["SECP256K1_BLAKE160"]!;
  const lockScript = {
    codeHash: template.CODE_HASH,
    hashType: template.HASH_TYPE,
    args: args,
  };

  return helpers.encodeToAddress(lockScript);
};

const privateKey = generateFirstHDPrivateKey();
const address = getAddressByPrivateKey(privateKey);
console.log("privateKey: ", privateKey);
console.log("address: ", address);
```

----------------------------------------

TITLE: Building and Sending CKB Transfer Transaction using Lumos (TypeScript)
DESCRIPTION: This snippet shows how to construct and send a CKB transfer transaction using `@ckb-lumos/lumos`. It defines an asynchronous `transfer` function that takes sender (`from`), recipient (`to`), capacity (in Shannons), and the sender's `privateKey`. It reuses the `indexer` and `rpc` instances initialized previously. It uses `commons.common.transfer` to build the base transaction, `payFeeByFeeRate` to handle fees, prepares signing entries, signs the transaction with the private key, seals it, and finally sends it using the RPC client. It assumes `address` and `privateKey` variables are defined elsewhere.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_10

LANGUAGE: TypeScript
CODE:
```
import { commons, Address, HexString, helpers, hd } from "@ckb-lumos/lumos";

const transfer = async (
  from: Address,
  to: Address,
  capacity: number,
  privateKey: HexString
) => {
  let txSkeleton = helpers.TransactionSkeleton({ cellProvider: indexer });

  // Build the base transaction
  txSkeleton = await commons.common.transfer(
    txSkeleton,
    [from],
    to,
    BigInt(capacity)
  );
  // Pay the transaction fee
  txSkeleton = await commons.common.payFeeByFeeRate(txSkeleton, [from], 1000);

  // Prepare signing entried and sign the transaction
  txSkeleton = commons.common.prepareSigningEntries(txSkeleton);
  const message = txSkeleton.get("signingEntries").get(0)?.message;
  const Sig = hd.key.signRecoverable(message!, privateKey);
  const tx = helpers.sealTransaction(txSkeleton, [Sig]);

  // Send the transaction
  return rpc.sendTransaction(tx, "passthrough");
};

const bobAddress =
  "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqgy5rtexzvhk7jt7gla8wlq5lztf79tjhg9fmd4f";
transfer(address, bobAddress, 100 * 10 ** 8, privateKey).then(
  (txHash: string) => console.log("txHash: ", txHash)
);
```

----------------------------------------

TITLE: Modifying Transaction Skeleton for Valid UDT Transfer - Lumos/CKB - JavaScript
DESCRIPTION: This snippet modifies the previously created transaction skeleton to correct the output UDT amount, making the transfer valid according to the UDT script's rules (input sum equals output sum). It updates the output cell's type and data, recalculates fees, prepares signing entries, signs the modified transaction, and sends it, demonstrating a successful UDT transfer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_10

LANGUAGE: JavaScript
CODE:
```
txSkeleton = txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = input.cellOutput.type;
  cell.data = bytes.hexify(Uint32LE.pack(1000000));
  return outputs;
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet2.address], 3000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet2.privkey)).toArray();
signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
let txHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Building CKB Transaction with Lumos (Duktape Script) - JavaScript
DESCRIPTION: Initializes a Lumos transaction skeleton, adds a transfer output, updates the output cell to include the duktape type script, adds the duktape script code as a cell dependency, pays the fee, prepares signing entries, signs the transaction, and sends it to the RPC.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_20

LANGUAGE: JavaScript
CODE:
```
const duktapeTypeScript =  {
  codeHash: duktapeCodeHash,
  hashType: "data",
  args: "0x370000000c00000033000000000000001f000000434b422e6465627567282249276d2072756e6e696e6720696e204a5322290a04000000"
};
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"200" + "00000000");
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = duktapeTypeScript;

```

----------------------------------------

TITLE: Checking CKB Address Balance using Lumos (TypeScript)
DESCRIPTION: This snippet demonstrates how to check the CKB balance of a given address using the `@ckb-lumos/lumos` library. It initializes RPC and Indexer instances (which are reused later), defines an asynchronous function `getCapacities` that collects cells associated with the provided `address` and sums their capacities, and then logs the result. The balance is returned in Shannons and converted to CKB for display. It assumes the `address` variable is defined elsewhere.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_8

LANGUAGE: TypeScript
CODE:
```
import { BI, RPC, Indexer, helpers } from "@ckb-lumos/lumos";

// CKB also provides an indexer rpc to help searching easily.
const TESTNET_RPC_URL = "https://testnet.ckb.dev/rpc";
const TESTNET_INDEXER_URL = "https://testnet.ckb.dev/indexer";

const rpc = new RPC(TESTNET_RPC_URL);
const indexer = new Indexer(TESTNET_INDEXER_URL, TESTNET_RPC_URL);

// Check CKB balance
async function getCapacities(address: string): Promise<BI> {
  const collector = indexer.collector({ lock: helpers.parseAddress(address) });

  let capacities = BI.from(0);
  for await (const cell of collector.collect()) {
    capacities = capacities.add(cell.cell_output.capacity);
  }

  return capacities;
}

console.log(`address: ${address}`);
getCapacities(address).then((capacities) =>
  console.log(`balance: ${capacities.div(10 ** 8).toString()} CKB`)
);
```

----------------------------------------

TITLE: Implementing sUDT Script Entry Point and Validation (Rust)
DESCRIPTION: This Rust function serves as the main entry point for the sUDT script. It first checks if the script is executing in owner mode, returning success immediately if true. Otherwise, it collects the total UDT amounts from input and output cells and validates that the output amount does not exceed the input amount, returning an error if the validation fails.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/sudt-script.mdx#_snippet_6

LANGUAGE: Rust
CODE:
```
pub fn program_entry() -> i8 {
    ckb_std::debug!("This is a sample UDT contract!");

    let script = load_script().unwrap();
    let args: Bytes = script.args().unpack();
    ckb_std::debug!("script args is {:?}", args);

    // Check if the script is in owner mode
    if check_owner_mode(&args) {
        return 0; // Success if in owner mode
    }

    // Collect amounts from input and output cells
    let inputs_amount: u128 = match collect_inputs_amount() {
        Ok(amount) => amount,
        Err(err) => return err as i8,
    };
    let outputs_amount = match collect_outputs_amount() {
        Ok(amount) => amount,
        Err(err) => return err as i8,
    };

    // Validate that inputs are greater than or equal to outputs
    if inputs_amount < outputs_amount {
        return Error::InvalidAmount as i8; // Error if invalid amount
    }

    0 // Success
}
```

----------------------------------------

TITLE: Signing CKB P2PKH Transaction - Python Pseudo Code
DESCRIPTION: This pseudo code outlines the process for signing a CKB P2PKH transaction. It involves grouping inputs, preparing the first witness with a placeholder lock, hashing the transaction hash and relevant witnesses using BLAKE2b, signing the resulting hash with the private key, and finally updating the witness with the generated signature.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-sign-a-tx.mdx#_snippet_0

LANGUAGE: Python
CODE:
```
def sign_tx(pk, tx):
	# Group transaction inputs for signing
    input_groups = compute_input_groups(tx.inputs)

    # Iterate through each group of inputs
    for indexes in input_groups:
        group_index = indexes[0]

        # Create a placeholder for the lock field in the first witness of the group
        dummy_lock = [0] * 65 # Placeholder, assuming a 65-byte lock field

        # Retrieve and deserialize the first witness in the group
        witness = tx.witnesses[group_index]
        witness_args = witness.deserialize()

        # Replace the lock field with the dummy placeholder
        witness_args.lock = dummy_lock

        # Initialize a new BLAKE2b hasher for creating the signature hash
        hasher = new_blake2b()

        # Hash the transaction hash
        hasher.update(tx.hash())

        # Hash the first witness
        witness_len_bytes = len(serialize(witness_args)).to_le()
        assert(len(witness_len_bytes), 8)

        # Hash the length of witness
        hasher.update(witness_len_bytes)
        hasher.update(serialize(witness_args))

        # Hash the remaining witnesses in the group
        for i in indexes[1:]:
            witness = tx.witnesses[i]
            witness_len_bytes = len(witness).to_le()
            assert(len(witness_len_bytes), 8)
            hasher.update(witness_len_bytes)
            hasher.update(witness)

        # Hash additional witnesses not in any input group
        for witness in tx.witnesses[len(tx.inputs):]
            witness_len_bytes = len(witness).to_le()
            assert(len(witness_len_bytes), 8)
            hasher.update(witness_len_bytes)
            hasher.update(witness)

        # Finalize the hasher to get the signature hash
        sig_hash = hasher.finalize()

        # Sign the transaction with private key
        signature = pk.sign(sig_hash)

        # Replace the dummy lock field with the actual signature in the first witness
        witness_args.lock = signature

        # Serialize the updated witness_args and update the transaction's witnesses list
        tx.witnesses[group_index] = serialize(witness_args)
```

----------------------------------------

TITLE: Generating New CKB Address (Go)
DESCRIPTION: Shows how to generate a new random private key and derive a secp256k1_blake160_signhash_all lock script from it. This script is then used to create and encode a new CKB address for the test network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_8

LANGUAGE: Go
CODE:
```
// Generate a new address randomly
key, err := secp256k1.RandomNew()
if err != nil {
	// handle error
}
script := systemscript.Secp256K1Blake160SignhashAll(key)
addr := &address.Address{Script: script, Network: types.NetworkTest}
encodedAddr, err := addr.Encode()
```

----------------------------------------

TITLE: Example CKB Transaction JSON
DESCRIPTION: Provides a complete JSON example illustrating the structure and fields of a CKB transaction, including version, cell dependencies, header dependencies, inputs, outputs, output data, and witnesses. This example demonstrates the format and typical values for each field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/transaction.md#_snippet_0

LANGUAGE: JSON
CODE:
```
{
  "version": "0x0",
  "cell_deps": [
    {
      "out_point": {
        "tx_hash": "0xbd864a269201d7052d4eb3f753f49f7c68b8edc386afc8bb6ef3e15a05facca2",
        "index": "0x0"
      },
      "dep_type": "dep_group"
    }
  ],
  "header_deps": [
    "0xaa1124da6a230435298d83a12dd6c13f7d58caf7853f39cea8aad992ef88a422"
  ],
  "inputs": [
    {
      "previous_output": {
        "tx_hash": "0x8389eba3ae414fb6a3019aa47583e9be36d096c55ab2e00ec49bdb012c24844d",
        "index": "0x1"
      },
      "since": "0x0"
    }
  ],
  "outputs": [
    {
      "capacity": "0x746a528800",
      "lock": {
        "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
        "args": "0x56008385085341a6ed68decfabb3ba1f3eea7b68",
        "hash_type": "type"
      },
      "type": null
    },
    {
      "capacity": "0x1561d9307e88",
      "lock": {
        "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
        "args": "0x886d23a7858f12ebf924baaacd774a5e2cf81132",
        "hash_type": "type"
      },
      "type": null
    }
  ],
  "outputs_data": [
    "0x",
    "0x"
  ],
  "witnesses": ["0x55000000100000005500000055000000410000004a975e08ff99fa000142ff3b86a836b43884b5b46f91b149f7cc5300e8607e633b7a29c94dc01c6616a12f62e74a1415f57fcc5a00e41ac2d7034e90edf4fdf800"]
}
```

----------------------------------------

TITLE: Reading Message from CKB Cell (TypeScript)
DESCRIPTION: This asynchronous function retrieves a specific CKB Live Cell using its transaction hash and output index, extracts the raw data, decodes it from hexadecimal to UTF-8, and displays it via an alert. It requires a CKB client instance (`cccClient`) and a hex-to-UTF8 decoding utility (`hexToUtf8`).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/write-message.mdx#_snippet_5

LANGUAGE: TypeScript
CODE:
```
export async function readOnChainMessage(txHash: string, index = "0x0") {\n  const cell = await cccClient.getCellLive({ txHash, index }, true);\n  if (cell == null) {\n    return alert("Cell not found, please retry later");\n  }\n  const data = cell.outputData;\n  const msg = hexToUtf8(data);\n  alert("read msg: " + msg);\n  return msg;\n}
```

----------------------------------------

TITLE: Loading Cell Data with CKB Syscalls C
DESCRIPTION: This CKB script demonstrates how to use syscalls, specifically `ckb_load_cell_data`, to read data from output cells. It iterates through output cells, loading the first 6 bytes of data into a buffer. If any cell's data starts with the string "carrot", the script returns -1, indicating failure; otherwise, it returns 0 upon checking all output cells.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_2

LANGUAGE: C
CODE:
```
#include <memory.h>
#include "ckb_syscalls.h"

int main(int argc, char* argv[]) {
  int ret;
  size_t index = 0;
  uint64_t len = 0; /* (1) */
  unsigned char buffer[6];

  while (1) {
    len = 6;
    memset(buffer, 0, 6);
    ret = ckb_load_cell_data(buffer, &len, 0, index, CKB_SOURCE_OUTPUT); /* (2) */
    if (ret == CKB_INDEX_OUT_OF_BOUND) {               /* (3) */
      break;
    }

    if (memcmp(buffer, "carrot", 6) == 0) {
      return -1;
    }

    index++;
  }

  return 0;
}
```

----------------------------------------

TITLE: Creating Transaction Using Deployed Script - Node.js
DESCRIPTION: This Node.js snippet, using @ckb-lumos/lumos, demonstrates how to create a transaction that utilizes the previously deployed duktape REPL script. It defines the script using the code hash of the deployed binary and the arguments generated by `native_args_assembler`. It then creates a transaction skeleton, transfers funds, sets the type script of an output cell to the duktape script, and adds the cell containing the deployed binary as a cell dependency.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_13

LANGUAGE: javascript
CODE:
```
> const duktapeReplCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
> const duktapeTypeScript = {
  codeHash: duktapeReplCodeHash,
  hashType: "data",
  args: "0x370000000c00000033000000000000001f000000434b422e6465627567282249276d2072756e6e696e6720696e204a5322290a04000000",
};
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"150" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = duktapeTypeScript;
  return outputs;
});
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: duktapeReplTxHash,
    index: "0x0",
  },
  depType: "code",
});
```

----------------------------------------

TITLE: Transfer CKB Tokens using Lumos and CKB-CCC (React/TypeScript)
DESCRIPTION: This React component handles state for transfer inputs, validates the recipient address using CKB-CCC, composes a CKB transfer transaction using Lumos common scripts (transfer, payFeeByFeeRate), converts the Lumos skeleton to a CKB-CCC transaction, adds optional output data, and finally signs and sends the transaction using the CKB-CCC signer. It depends on @ckb-ccc/connector-react, @ckb-lumos/common-scripts, @ckb-lumos/ckb-indexer, and React hooks.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_10

LANGUAGE: TypeScript
CODE:
```
"use client";

import React, { useState } from "react";
import { TextInput } from "@/src/components/Input";
import { Button } from "@/src/components/Button";
import { ccc } from "@ckb-ccc/connector-react";
import common,
  { registerCustomLockScriptInfos,
} from "@ckb-lumos/common-scripts/lib/common";
import { generateDefaultScriptInfos } from "@ckb-ccc/lumos-patches";
import { Indexer } from "@ckb-lumos/ckb-indexer";
import { TransactionSkeleton } from "@ckb-lumos/helpers";
import { predefined } from "@ckb-lumos/config-manager";
import { Textarea } from "@/src/components/Textarea";
import { useGetExplorerLink } from "@/src/utils";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function TransferLumos() {
  const { signer, createSender } = useApp();
  const { log, error } = createSender("Transfer with Lumos");

  const { explorerTransaction } = useGetExplorerLink();

  const [transferTo, setTransferTo] = useState<string>("");
  const [amount, setAmount] = useState<string>("");
  const [data, setData] = useState<string>("");
  return (
    <div className="flex w-full flex-col items-stretch">
      <TextInput
        label="Address"
        placeholder="Address to transfer to"
        state={[transferTo, setTransferTo]}
      />
      <TextInput
        label="Amount"
        placeholder="Amount to transfer"
        state={[amount, setAmount]}
      />
      <Textarea
        label="Output Data(options)"
        state={[data, setData]}
        placeholder="Data in the cell. Hex string will be parsed."
      />
      <ButtonsPanel>
        <Button
          className="self-center"
          onClick={async () => {
            if (!signer) {
              return;
            }
            // Verify destination address
            await ccc.Address.fromString(transferTo, signer.client);

            const fromAddresses = await signer.getAddresses();
            // === Composing transaction with Lumos ===
            registerCustomLockScriptInfos(generateDefaultScriptInfos());
            const indexer = new Indexer(
              signer.client.url
                .replace("wss://", "https://")
                .replace("ws://", "http://")
                .replace(new RegExp("/ws/?$"), "/")
            );
            let txSkeleton = new TransactionSkeleton({
              cellProvider: indexer,
            });
            txSkeleton = await common.transfer(
              txSkeleton,
              fromAddresses,
              transferTo,
              ccc.fixedPointFrom(amount),
              undefined,
              undefined,
              {
                config:
                  signer.client.addressPrefix === "ckb"
                    ? predefined.LINA
                    : predefined.AGGRON4,
              }
            );
            txSkeleton = await common.payFeeByFeeRate(
              txSkeleton,
              fromAddresses,
              BigInt(3600),
              undefined,
              {
                config:
                  signer.client.addressPrefix === "ckb"
                    ? predefined.LINA
                    : predefined.AGGRON4,
              }
            );
            // ======

            const tx = ccc.Transaction.fromLumosSkeleton(txSkeleton);

            // CCC transactions are easy to be edited
            const dataBytes = (() => {
              try {
                return ccc.bytesFrom(data);
              } catch (e) {}

              return ccc.bytesFrom(data, "utf8");
            })();
            if (tx.outputs[0].capacity < ccc.fixedPointFrom(dataBytes.length)) {
              error("Insufficient capacity to store data");
              return;
            }
            tx.outputsData[0] = ccc.hexFrom(dataBytes);

            // Sign and send the transaction
            log(
              "Transaction sent:",
              explorerTransaction(await signer.sendTransaction(tx))
            );
          }}
        >
          Transfer
        </Button>
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Issue xUDT Tokens with Type ID using CKB CCC (TSX)
DESCRIPTION: This React functional component provides a UI and logic for issuing xUDT tokens. It allows the user to specify token details (amount, decimals, symbol, name) and optionally provide an existing Type ID args or create a new one. It orchestrates the necessary CKB transactions (creating Type ID cell if needed, creating owner cell, and minting tokens) using the CKB CCC library and a connected signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_13

LANGUAGE: tsx
CODE:
```
"use client";

import React, { useState } from "react";
import { TextInput } from "@/src/components/Input";
import { Button } from "@/src/components/Button";
import { ccc } from "@ckb-ccc/connector-react";
import { tokenInfoToBytes, useGetExplorerLink } from "@/src/utils";
import { Message } from "@/src/components/Message";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";
import Link from "next/link";

export default function IssueXUdtTypeId() {
  const { signer, createSender } = useApp();
  const { log, error } = createSender("Issue xUDT (Type ID)");

  const { explorerTransaction } = useGetExplorerLink();

  const [typeIdArgs, setTypeIdArgs] = useState<string>("");
  const [amount, setAmount] = useState<string>("");
  const [decimals, setDecimals] = useState<string>("");
  const [name, setName] = useState<string>("");
  const [symbol, setSymbol] = useState<string>("");

  return (
    <div className="flex w-full flex-col items-stretch">
      <Message title="Hint" type="info">
        You will need to sign two or three transactions.
      </Message>
      <TextInput
        label="Type ID(options)"
        placeholder="Type ID args, empty to create new"
        state={[typeIdArgs, setTypeIdArgs]}
      />
      <TextInput
        label="Amount"
        placeholder="Amount to issue"
        state={[amount, setAmount]}
      />
      <TextInput
        label="Decimals"
        placeholder="Decimals of the token"
        state={[decimals, setDecimals]}
      />
      <TextInput
        label="Symbol"
        placeholder="Symbol of the token"
        state={[symbol, setSymbol]}
      />
      <TextInput
        label="Name (options)"
        placeholder="Name of the token, same as symbol if empty"
        state={[name, setName]}
      />
      <ButtonsPanel>
        <Button
          className="self-center"
          onClick={async () => {
            if (!signer) {
              return;
            }
            const { script } = await signer.getRecommendedAddressObj();
            if (decimals === "" || symbol === "") {
              error("Invalid token info");
              return;
            }

            const typeId = await (async () => {
              if (typeIdArgs !== "") {
                return ccc.Script.fromKnownScript(
                  signer.client,
                  ccc.KnownScript.TypeId,
                  typeIdArgs
                );
              }
              const typeIdTx = ccc.Transaction.from({
                outputs: [
                  {
                    lock: script,
                    type: await ccc.Script.fromKnownScript(
                      signer.client,
                      ccc.KnownScript.TypeId,
                      "00".repeat(32)
                    ),
                  },
                ],
              });
              await typeIdTx.completeInputsByCapacity(signer);
              if (!typeIdTx.outputs[0].type) {
                error("Unexpected disappeared output");
                return;
              }
              typeIdTx.outputs[0].type.args = ccc.hashTypeId(
                typeIdTx.inputs[0],
                0
              );
              await typeIdTx.completeFeeBy(signer);
              log(
                "Transaction sent:",
                explorerTransaction(await signer.sendTransaction(typeIdTx))
              );
              log("Type ID created: ", typeIdTx.outputs[0].type.args);
              return typeIdTx.outputs[0].type;
            })();
            if (!typeId) {
              return;
            }

            const outputTypeLock = await ccc.Script.fromKnownScript(
              signer.client,
              ccc.KnownScript.OutputTypeProxyLock,
              typeId.hash()
            );
            const lockTx = ccc.Transaction.from({
              outputs: [
                // Owner cell
                {
                  lock: outputTypeLock,
                },
              ],
            });
            await lockTx.completeInputsByCapacity(signer);
            await lockTx.completeFeeBy(signer);
            const lockTxHash = await signer.sendTransaction(lockTx);
            log("Transaction sent:", explorerTransaction(lockTxHash));

            const typeIdCell = await signer.client.findSingletonCellByType(
              typeId
            );
            if (!typeIdCell) {
              error("Type ID cell not found");
              return;
            }
            const mintTx = ccc.Transaction.from({
              inputs: [
                // Type ID
                {
                  previousOutput: typeIdCell.outPoint,
                },
                // Owner cell
                {
                  previousOutput: {
                    txHash: lockTxHash,
                    index: 0,
                  },
                },

```

----------------------------------------

TITLE: Converting Public Key to CKB Address (Go)
DESCRIPTION: Illustrates how to create a secp256k1_blake160_signhash_all lock script directly from a compressed elliptic curve public key string (33 bytes). This script is then used to construct a CKB address object for the test network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_9

LANGUAGE: Go
CODE:
```
// You should provide an elliptic curve public key of compressed format, with 33 bytes.
script, err := systemscript.Secp256K1Blake160SignhashAllByPublicKey("0x03a0a7a7597b019828a1dda6ed52ab25181073ec3a9825d28b9abbb932fe1ec83d")
if err != nil {
	// handle error
}
addr := &address.Address{Script: script, Network: types.NetworkTest}
```

----------------------------------------

TITLE: Sign and Send Transaction - TypeScript
DESCRIPTION: Signs the constructed transaction using the issuer's signer and sends it to the CKB network. The transaction hash is then logged to the console.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_4

LANGUAGE: ts
CODE:
```
const txHash = await signer.sendTransaction(tx);
console.log("The transaction hash is", hash);
```

----------------------------------------

TITLE: Decrypt CKB Keystore and Derive Accounts - TSX
DESCRIPTION: This React component handles the decryption of a CKB keystore file using a provided password and derives hierarchical deterministic (HD) accounts from the resulting HD key. It uses `@ckb-ccc/connector-react` for CKB interactions and `@scure/bip32` for HD key operations. Users can specify the number of accounts to derive and view their path, address, and private key, with an option to save the data as a CSV file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_28

LANGUAGE: tsx
CODE:
```
"use client";

import { ccc } from "@ckb-ccc/connector-react";
import React, { useCallback, useEffect, useState } from "react";
import { Button } from "@/src/components/Button";
import { TextInput } from "@/src/components/Input";
import { HDKey } from "@scure/bip32";
import { Textarea } from "@/src/components/Textarea";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function Keystore() {
  const { client } = ccc.useCcc();
  const { createSender } = useApp();
  const { log, error } = createSender("Keystore");

  const [keystore, setKeystore] = useState<string>("");
  const [password, setPassword] = useState<string>("");
  const [countStr, setCountStr] = useState<string>("10");
  const [accounts, setAccount] = useState<
    {
      publicKey: string;
      privateKey: string;
      address: string;
      path: string;
    }[]
  >([]);
  const [hdKey, setHdKey] = useState<HDKey | undefined>(undefined);
  const moreAccounts = useCallback(async () => {
    if (!hdKey) {
      return;
    }
    const count = parseInt(countStr, 10);
    setAccount((accounts) => [
      ...accounts,
      ...Array.from(new Array(count), (_, i) => {
        const path = `m/44'/309'/0'/0/${i + accounts.length}`;
        const derivedKey = hdKey.derive(path);
        return {
          publicKey: ccc.hexFrom(derivedKey.publicKey!),
          privateKey: ccc.hexFrom(derivedKey.privateKey!),
          path,
          address: "",
        };
      }),
    ]);
  }, [hdKey, countStr]);
  useEffect(() => {
    setAccount([]);
    moreAccounts();
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [hdKey]);

  useEffect(() => {
    setAccount([]);
    setHdKey(undefined);
  }, [keystore, password]);

  useEffect(() => {
    (async () => {
      let modified = false;
      const newAccounts = await Promise.all(
        accounts.map(async (acc) => {
          const address = await new ccc.SignerCkbPublicKey(
            client,
            acc.publicKey,
          ).getRecommendedAddress();
          if (address !== acc.address) {
            modified = true;
          }
          acc.address = address;
          return acc;
        }),
      );
      if (modified) {
        setAccount(newAccounts);
      }
    })();
  }, [client, accounts]);

  return (
    <div className="flex w-full flex-col items-stretch">
      <Textarea
        label="keystore"
        placeholder="Keystore"
        state={[keystore, setKeystore]}
      />
      <TextInput
        label="Accounts count"
        placeholder="Accounts count"
        state={[countStr, setCountStr]}
      />
      <TextInput
        label="Password"
        placeholder="Password"
        state={[password, setPassword]}
      />
      {accounts.length !== 0 ? (
        <div className="mt-1 w-full overflow-scroll whitespace-nowrap bg-white">
          <p>path, address, private key</p>
          {accounts.map(({ privateKey, address, path }) => (
            <p key={path}>
              {path}, {address}, {privateKey}
            </p>
          ))}
        </div>
      ) : undefined}
      <ButtonsPanel>
        <Button
          variant="success"
          onClick={async () => {
            try {
              const { privateKey, chainCode } = await ccc.keystoreDecrypt(
                JSON.parse(keystore),
                password,
              );
              setHdKey(new HDKey({ privateKey, chainCode }));
            } catch (err) {
              error("Invalid");
              throw err;
            }
            log("Valid");
          }}
        >
          Verify Keystore
        </Button>
        <Button
          className="ml-2"
          onClick={moreAccounts}
          disabled={!hdKey || Number.isNaN(parseInt(countStr, 10))}
        >
          More accounts
        </Button>
        {accounts.length !== 0 ? (
          <Button
            as="a"
            className="ml-2"
            href={`data:application/octet-stream,path%2C%20address%2C%20private%20key%0A${accounts
              .map(({ privateKey, address, path }) =>
                encodeURIComponent(`${path}, ${address}, ${privateKey}`),
              )
              .join("\n")}`}
            download={`ckb_accounts_${Date.now()}.csv`}
          >
            Save as CSV
          </Button>
        ) : undefined}
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Implement Carrot Forbidden Logic with CKB-STD Rust
DESCRIPTION: This Rust code implements the core logic for the "carrot-forbidden" CKB script. It iterates through the data of output cells using `ckb_std::high_level::load_cell_data` and checks if any cell data starts with the bytes representing "carrot". If found, it returns a specific error code; otherwise, it returns success after checking all relevant output cells.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_7

LANGUAGE: Rust
CODE:
```
#![no_std]
#![cfg_attr(not(test), no_main)]

#[cfg(test)]
extern crate alloc;

mod error;

use ckb_std::{ckb_constants::Source, debug, error::SysError, high_level::load_cell_data};

#[cfg(not(test))]
use ckb_std::default_alloc;
use error::Error;
#[cfg(not(test))]
ckb_std::entry!(program_entry);
#[cfg(not(test))]
default_alloc!();

pub fn program_entry() -> i8 {
    match carrot_forbidden() {
        Ok(_) => 0,
        Err(err) => err as i8,
    }
}

fn carrot_forbidden() -> Result<(), Error> {
    let mut index = 0;
    loop {
        match load_cell_data(index, Source::GroupOutput) {
            Ok(data) => {
                if data.starts_with("carrot".as_bytes()) {
                    return Err(Error::CarrotAttack);
                }else{
                    debug!("output #{:} has no carrot! Hooray!", index);
                }
            },
            Err(err) => {
                match err {
                    // we loop out all the output cell
                    SysError::IndexOutOfBound => break,
                    _ => return Err(Error::from(err)),
                }
            }
        }
        // Increment index to process next cell
        index += 1;
    }
    Ok(())
}
```

----------------------------------------

TITLE: Write CKB Contract Unit Test in Rust
DESCRIPTION: Demonstrates how to write a unit test for CKB contracts using `ckb-testtool`. It deploys caller and callee contracts, prepares transaction inputs/outputs, defines cell dependencies, builds and completes a transaction, and verifies its execution using `context.verify_tx`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_13

LANGUAGE: Rust
CODE:
```
use crate::Loader;
use ckb_testtool::ckb_types::{
    bytes::Bytes,
    core::TransactionBuilder,
    packed::*,
    prelude::*,
};
use ckb_testtool::context::Context;

// Include your tests here
// See https://github.com/xxuejie/ckb-native-build-sample/blob/main/tests/src/tests.rs for more examples

// generated unit test for contract caller
#[test]
fn test_spawn() {
    // deploy contract
    let mut context = Context::default();
    let caller_contract_bin: Bytes = Loader::default().load_binary("caller");
    let caller_out_point = context.deploy_cell(caller_contract_bin);
    let callee_contract_bin: Bytes = Loader::default().load_binary("callee");
    let callee_out_point = context.deploy_cell(callee_contract_bin);

    // prepare scripts
    let lock_script = context
        .build_script(&caller_out_point, Bytes::from(vec![42]))
        .expect("script");

    // prepare cells
    let input_out_point = context.create_cell(
        CellOutput::new_builder()
            .capacity(1000u64.pack())
            .lock(lock_script.clone())
            .build(),
        Bytes::new(),
    );
    let input = CellInput::new_builder()
        .previous_output(input_out_point)
        .build();
    let outputs = vec![
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script.clone())
            .build(),
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script)
            .build(),
    ];

    let outputs_data = vec![Bytes::new(); 2];

    // prepare cell deps
    let callee_dep = CellDep::new_builder()
        .out_point(callee_out_point)
        .build();
    let caller_dep = CellDep::new_builder()
        .out_point(caller_out_point)
        .build();
    let cell_deps: Vec<CellDep> = vec![callee_dep, caller_dep];

    // build transaction
    let tx = TransactionBuilder::default()
        .input(input)
        .outputs(outputs)
        .outputs_data(outputs_data.pack())
        .cell_deps(cell_deps)
        .build();
    let tx = context.complete_tx(tx);

    // run
    let cycles = context
        .verify_tx(&tx, 10_000_000)
        .expect("pass verification");
    println!("consume cycles: {}", cycles);
}
```

----------------------------------------

TITLE: Transferring xUDT Tokens using CKB Connector (TSX)
DESCRIPTION: This TSX React component provides a user interface and logic to transfer xUDT tokens. It takes the xUDT args, recipient addresses (newline separated), and amount as input, uses the CKB Connector (`ccc`) to parse addresses, build a transaction with multiple outputs, complete inputs based on UDT balance and capacity, calculate change, add necessary cell dependencies, calculate the fee, and finally signs and sends the transaction via the connected signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_15

LANGUAGE: tsx
CODE:
```
"use client";

import React, { useState } from "react";
import { TextInput } from "@/src/components/Input";
import { Button } from "@/src/components/Button";
import { ccc } from "@ckb-ccc/connector-react";
import { Textarea } from "@/src/components/Textarea";
import { useGetExplorerLink } from "@/src/utils";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function TransferXUdt() {
  const { signer, createSender } = useApp();
  const { log } = createSender("Transfer xUDT");
  const { explorerTransaction } = useGetExplorerLink();

  const [xUdtArgs, setXUdtArgs] = useState<string>("");
  const [transferTo, setTransferTo] = useState<string>("");
  const [amount, setAmount] = useState<string>("");

  return (
    <div className="flex w-full flex-col items-stretch">
      <TextInput
        label="Args"
        placeholder="xUdt args to transfer"
        state={[xUdtArgs, setXUdtArgs]}
      />
      <Textarea
        label="Address"
        placeholder="Addresses to transfer to, separated by lines"
        state={[transferTo, setTransferTo]}
      />
      <TextInput
        label="amount"
        placeholder="Amount to transfer for each"
        state={[amount, setAmount]}
      />
      <ButtonsPanel>
        <Button
          className="self-center"
          onClick={async () => {
            if (!signer) {
              return;
            }
            const toAddresses = await Promise.all(
              transferTo
                .split("\n")
                .map((addr) => ccc.Address.fromString(addr, signer.client))
            );
            const { script: change } = await signer.getRecommendedAddressObj();

            const xUdtType = await ccc.Script.fromKnownScript(
              signer.client,
              ccc.KnownScript.XUdt,
              xUdtArgs
            );

            const tx = ccc.Transaction.from({
              outputs: toAddresses.map(({ script }) => ({
                lock: script,
                type: xUdtType,
              })),
              outputsData: Array.from(Array(toAddresses.length), () =>
                ccc.numLeToBytes(amount, 16)
              ),
            });
            await tx.completeInputsByUdt(signer, xUdtType);
            const balanceDiff =
              (await tx.getInputsUdtBalance(signer.client, xUdtType)) -
              tx.getOutputsUdtBalance(xUdtType);
            if (balanceDiff > ccc.Zero) {
              tx.addOutput(
                {
                  lock: change,
                  type: xUdtType,
                },
                ccc.numLeToBytes(balanceDiff, 16)
              );
            }
            await tx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.XUdt
            );
            await tx.completeInputsByCapacity(signer);
            await tx.completeFeeBy(signer, 2000);

            // Sign and send the transaction
            log(
              "Transaction sent:",
              explorerTransaction(await signer.sendTransaction(tx))
            );
          }}
        >
          Transfer
        </Button>
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Sign and Broadcast Transaction (TypeScript)
DESCRIPTION: The final step in the `buildMessageTx` function, showing how the transaction signer is used to sign the completed transaction and then broadcast it to the CKB network via an RPC call. This action commits the new Cell containing the message to the blockchain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/write-message.mdx#_snippet_4

LANGUAGE: typescript
CODE:
```
const txHash = await signer.sendTransaction(tx);
```

----------------------------------------

TITLE: Perform Nervos DAO Deposit Transaction (TypeScript)
DESCRIPTION: This snippet constructs and sends a transaction to deposit a specified amount of CKB into the Nervos DAO. It initializes a transaction with the correct lock and type scripts, adds cell dependencies, validates the deposit amount against the minimum required capacity, completes inputs and fee calculation, signs the transaction, and sends it to the network, waiting for it to be committed.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_26

LANGUAGE: TypeScript
CODE:
```
onClick={async () => {
            if (!signer) {
              return;
            }

            const { script: lock } = await signer.getRecommendedAddressObj();

            const tx = ccc.Transaction.from({
              outputs: [
                {
                  lock,
                  type: await ccc.Script.fromKnownScript(
                    signer.client,
                    ccc.KnownScript.NervosDao,
                    "0x"
                  ),
                },
              ],
              outputsData: ["00".repeat(8)],
            });
            await tx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.NervosDao
            );

            if (tx.outputs[0].capacity > ccc.fixedPointFrom(amount)) {
              error(
                "Insufficient capacity at output, min",
                ccc.fixedPointToString(tx.outputs[0].capacity),
                "CKB"
              );
              return;
            }
            tx.outputs[0].capacity = ccc.fixedPointFrom(amount);

            await tx.completeInputsByCapacity(signer);
            await tx.completeFeeBy(signer, feeRate);

            // Sign and send the transaction
            const txHash = await signer.sendTransaction(tx);
            log("Transaction sent:", explorerTransaction(txHash));
            await signer.client.waitTransaction(txHash);
            log("Transaction committed:", explorerTransaction(txHash));
          }}
```

----------------------------------------

TITLE: Rust Struct for CellOutput
DESCRIPTION: Defines the `CellOutput` struct in Rust, which represents the output structure of a cell in CKB. It includes fields for `capacity`, the required `lock` script, and the optional `type` script, showing that both lock and type fields use the `Script` structure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-1.md#_snippet_0

LANGUAGE: Rust
CODE:
```
pub struct CellOutput {
    pub capacity: Capacity,
    pub lock: Script,
    #[serde(rename = "type")]
    pub type_: Option<Script>,
}
```

----------------------------------------

TITLE: Structure of a CKB Cell (Bash)
DESCRIPTION: Defines the fundamental structure of a Cell in Nervos CKB, listing its core fields: capacity, lock, type, and data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/cell.md#_snippet_0

LANGUAGE: bash
CODE:
```
Cell: {
  capacity: HexString;
  lock: Script;
  type: Script;
  data: HexString;
}
```

----------------------------------------

TITLE: Installing OffCKB CLI (Bash)
DESCRIPTION: Installs the offCKB command-line interface globally using npm. This tool is essential for quickly setting up a local CKB development environment and using pre-built boilerplates.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
npm install -g @offckb/cli
```

----------------------------------------

TITLE: Summing Output UDTs and Comparing (JavaScript)
DESCRIPTION: Iterates through all output cells within the current script group using `CKB.raw_load_cell_data`, summing their UDT amounts. It then compares the total `output_coins` with the previously calculated `input_coins`. If they are not equal, the script throws an error, enforcing the UDT transfer rule.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_1

LANGUAGE: JavaScript
CODE:
```
var output_index = 0;
var output_coins = 0;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, output_index, CKB.SOURCE.GROUP_OUTPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid output cell!";
  }
  var view = new DataView(buffer);
  output_coins += view.getUint32(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  throw "Input coins do not equal output coins!";
}
```

----------------------------------------

TITLE: Rust SDK Omnilock Transaction Example
DESCRIPTION: Demonstrates the process of creating, signing, and sending a transaction utilizing the Omnilock Script with the Nervos Rust SDK. It includes steps for setting up the transaction builder, adding outputs, configuring Omnilock context, signing the transaction with a private key, and broadcasting it to the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_3

LANGUAGE: Rust
CODE:
```
use ckb_sdk::{
    constants::ONE_CKB,
    transaction::{
        builder::{CkbTransactionBuilder, SimpleTransactionBuilder},
        handler::{omnilock, HandlerContexts},
        input::InputIterator,
        signer::{SignContexts, TransactionSigner},
        TransactionBuilderConfiguration,
    },
    unlock::OmniLockConfig,
    Address, CkbRpcClient, NetworkInfo,
};
use ckb_types::{
    h256,
    packed::CellOutput,
    prelude::{Builder, Entity, Pack},
};
use std::{error::Error as StdErr, str::FromStr};

fn main() -> Result<(), Box<dyn StdErr>> {
    let network_info = NetworkInfo::testnet();
    let sender = Address::from_str("ckt1qrejnmlar3r452tcg57gvq8patctcgy8acync0hxfnyka35ywafvkqgqgpy7m88v3gxnn3apazvlpkkt32xz3tg5qq3kzjf3")?;
    let receiver = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqv5dsed9par23x4g58seaw58j3ym5ml2hs8ztche")?;

    let configuration = TransactionBuilderConfiguration::new_with_network(network_info.clone())?;

    let iterator = InputIterator::new_with_address(&[sender.clone()], configuration.network_info());
    let mut builder = SimpleTransactionBuilder::new(configuration, iterator);

    let output = CellOutput::new_builder()
        .capacity((128 * ONE_CKB).pack())
        .lock((&receiver).into())
        .build();
    builder.add_output_and_data(output.clone(), ckb_types::packed::Bytes::default());
    builder.set_change_lock((&sender).into());

    let omni_cfg = OmniLockConfig::from_addr(&sender).unwrap();
    let context = omnilock::OmnilockScriptContext::new(omni_cfg.clone(), network_info.url.clone());

    let mut contexts = HandlerContexts::default();
    contexts.add_context(Box::new(context) as Box<_>);

    let mut tx_with_groups = builder.build(&mut contexts)?;

    let json_tx = ckb_jsonrpc_types::TransactionView::from(tx_with_groups.get_tx_view().clone());
    println!("tx: {}", serde_json::to_string_pretty(&json_tx).unwrap());

    let private_key = h256!("0x6c9ed03816e3111e49384b8d180174ad08e29feb1393ea1b51cef1c505d4e36a");
    TransactionSigner::new(&network_info).sign_transaction(
        &mut tx_with_groups,
        &SignContexts::new_omnilock(
            [secp256k1::SecretKey::from_slice(private_key.as_bytes())?].to_vec(),
            omni_cfg,
        ),
    )?;

    let json_tx = ckb_jsonrpc_types::TransactionView::from(tx_with_groups.get_tx_view().clone());
    println!("tx: {}", serde_json::to_string_pretty(&json_tx).unwrap());

    let tx_hash = CkbRpcClient::new(network_info.url.as_str())
        .send_transaction(json_tx.inner, None)
        .expect("send transaction");
    // example tx: 0xc0c9954a3299b540e63351146a301438372abf93682d96c7cce691c334dd5757
    println!(">>> tx {} sent! <<<", tx_hash);

    Ok(())
}
```

----------------------------------------

TITLE: Constructing CKB Transfer Transaction (Rust)
DESCRIPTION: Demonstrates how to build a C CKB capacity transfer transaction using the ckb-sdk. It covers setting up RPC client, defining sender and receiver addresses, specifying capacity, building unlockers, balancers, resolvers, and finally constructing the transaction object.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/rust.mdx#_snippet_7

LANGUAGE: Rust
CODE:
```
use ckb_sdk::{
    constants::SIGHASH_TYPE_HASH,
    rpc::CkbRpcClient,
    traits::{
        DefaultCellCollector, DefaultCellDepResolver, DefaultHeaderDepResolver,
        DefaultTransactionDependencyProvider, SecpCkbRawKeySigner,
    },
    tx_builder::{transfer::CapacityTransferBuilder, CapacityBalancer, TxBuilder},
    unlock::{ScriptUnlocker, SecpSighashUnlocker},
    Address, HumanCapacity, ScriptId,
};
use ckb_types::{
    bytes::Bytes,
    core::BlockView,
    h256,
    packed::{CellOutput, Script, WitnessArgs},
    prelude::*,
};
use std::{collections::HashMap, str::FromStr};

// Prepare the necessary data for a CKB transaction:
//   * set the RPC endpoint for the testnet
//   * define the sender's address and secret key
//   * define the recipient's address
//   * specify the capacity to transfer
let ckb_rpc = "https://testnet.ckb.dev:8114";
let sender = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqf7v2xsyj0p8szesqrwqapvvygpc8hzg9sku954v").unwrap();
let sender_key = secp256k1::SecretKey::from_slice(
    h256!("0xef4dfe655b3df20838bdd16e20afc70dfc1b9c3e87c54c276820315a570e6555").as_bytes(),
)
.unwrap();
let receiver = Address::from_str("ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvglkprurm00l7hrs3rfqmmzyy3ll7djdsujdm6z").unwrap();
let capacity = HumanCapacity::from_str("100.0").unwrap();

 // Build ScriptUnlocker
let signer = SecpCkbRawKeySigner::new_with_secret_keys(vec![sender_key]);
let sighash_unlocker = SecpSighashUnlocker::from(Box::new(signer) as Box<_>);
let sighash_script_id = ScriptId::new_type(SIGHASH_TYPE_HASH.clone());
let mut unlockers = HashMap::default();
unlockers.insert(
    sighash_script_id,
    Box::new(sighash_unlocker) as Box<dyn ScriptUnlocker>,
);

// Build CapacityBalancer
let placeholder_witness = WitnessArgs::new_builder()
    .lock(Some(Bytes::from(vec![0u8; 65])).pack())
    .build();
let balancer = CapacityBalancer::new_simple(sender.payload().into(), placeholder_witness, 1000);

// Build:
//   * CellDepResolver
//   * HeaderDepResolver
//   * CellCollector
//   * TransactionDependencyProvider
let mut ckb_client = CkbRpcClient::new(ckb_rpc);
let cell_dep_resolver = {
    let genesis_block = ckb_client.get_block_by_number(0.into()).unwrap().unwrap();
    DefaultCellDepResolver::from_genesis(&BlockView::from(genesis_block)).unwrap()
};
let header_dep_resolver = DefaultHeaderDepResolver::new(ckb_rpc);
let mut cell_collector = DefaultCellCollector::new(ckb_rpc);
let tx_dep_provider = DefaultTransactionDependencyProvider::new(ckb_rpc, 10);

// Build the transaction
let output = CellOutput::new_builder()
    .lock(Script::from(&receiver))
    .capacity(capacity.0.pack())
    .build();
let builder = CapacityTransferBuilder::new(vec![(output, Bytes::default())]);
let (_tx, _) = builder
    .build_unlocked(
        &mut cell_collector,
        &cell_dep_resolver,
        &header_dep_resolver,
        &tx_dep_provider,
        &balancer,
        &unlockers,
    )
    .unwrap();
```

----------------------------------------

TITLE: Calculate CKB Hash - TSX
DESCRIPTION: This React functional component calculates the CKB hash of a user-provided message using the `ccc.hashCkb` function from the `@ckb-ccc/connector-react` library. It provides options to hash the input string interpreted as UTF-8 or as a hex string.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_8

LANGUAGE: tsx
CODE:
```
"use client";

import { ccc } from "@ckb-ccc/connector-react";
import React, { useState } from "react";
import { Button } from "@/src/components/Button";
import { TextInput } from "@/src/components/Input";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function Hash() {
  const { createSender } = useApp();
  const { log } = createSender("Hash");

  const [messageToHash, setMessageToHash] = useState<string>("");

  return (
    <div className="flex w-full flex-col items-stretch">
      <TextInput
        label="Message"
        placeholder="Message to hash"
        state={[messageToHash, setMessageToHash]}
      />
      <ButtonsPanel>
        <Button
          onClick={async () => {
            log("Hash:", ccc.hashCkb(ccc.bytesFrom(messageToHash, "utf8")));
          }}
        >
          Hash as UTF-8
        </Button>
        <Button
          className="ml-2"
          onClick={async () => {
            log("Hash:", ccc.hashCkb(messageToHash));
          }}
        >
          Hash as hex
        </Button>
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Signing and Sending CKB Transaction (TypeScript)
DESCRIPTION: This snippet concludes the `transfer` function implementation. It uses the signer to sign the completed transaction and sends it to the CKB network. It then logs the transaction hash and returns it. Requires the signed transaction object (`tx`) and the signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_6

LANGUAGE: TypeScript
CODE:
```
// ...
const txHash = await signer.sendTransaction(tx);
console.log(
  `Go to explorer to check the sent transaction https://pudge.explorer.nervos.org/transaction/${txHash}`
);

return txHash;
```

----------------------------------------

TITLE: Generating Hash Lock Account and Address (TypeScript)
DESCRIPTION: This function takes a hash string, uses it as `script_args` for the `hash_lock` script template from `offCKB`, constructs a Lock Script object, and derives a CKB address from it using `ccc.Address.fromScript`. It returns both the address string and the `ccc.Script` object.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/simple-lock.mdx#_snippet_6

LANGUAGE: TypeScript
CODE:
```
// ...
export function generateAccount(hash: string) {
  const lockArgs = "0x" + hash;
  const lockScript = {
    codeHash: offCKB.myScripts["hash-lock"]!.codeHash,
    hashType: offCKB.myScripts["hash-lock"]!.hashType,
    args: lockArgs,
  };
  const address = ccc.Address.fromScript(lockScript, cccClient).toString();
  return {
    address,
    lockScript: ccc.Script.from(lockScript),
  };
}
// ...
```

----------------------------------------

TITLE: Sign and Send CKB Transaction (Success)
DESCRIPTION: This snippet demonstrates how to sign a prepared transaction skeleton using a private key and send it to the CKB network via an RPC client. It assumes the transaction skeleton is valid and passes script validation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_11

LANGUAGE: JavaScript
CODE:
```
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
const txHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Add Cell Dependency for Script Location (JavaScript)
DESCRIPTION: Adds a cell dependency (`cellDep`) to the transaction skeleton. This dependency points to the cell created in a previous step (`carrotTxHash`, index `0x0`) which contains the actual compiled script code. The `depType` is set to "code", indicating that this dependency provides code that the transaction might execute. This allows CKB to locate and load the script binary.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_9

LANGUAGE: js
CODE:
```
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0"
  },
  depType: "code"
})
```

----------------------------------------

TITLE: Loading and Deserializing CKB Script and Args (JavaScript)
DESCRIPTION: Loads the necessary Molecule schemas (blockchain and custom htlc), defines helper functions for converting bytes to hex strings, loads the current CKB script using a syscall, extracts its arguments, and deserializes the arguments using the HtlcArgs schema.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_12

LANGUAGE: javascript
CODE:
```
const { Molecule } = require('molecule-javascript')
const schema = require('../schema/blockchain-combined.json')

const names = schema.declarations.map(declaration => declaration.name)
const scriptTypeIndex = names.indexOf('Script')
const scriptType = new Molecule(schema.declarations[scriptTypeIndex])

// Write your script logic here.
const customSchema = require('./htlc-combined.json')
const customNames = customSchema.declarations.map(d => d.name)

const htlcArgsIndex = customNames.indexOf('HtlcArgs')
const htlcArgsType = new Molecule(customSchema.declarations[htlcArgsIndex])

function bytesToHex(b) {
  return "0x" + Array.prototype.map.call(
    new Uint8Array(b),
    function(x) {
      return ('00' + x.toString(16)).slice(-2)
    }
  ).join('')
}

function hexStringArrayToHexString(a) {
  let s = "0x";
  for (let i = 0; i < a.length; i++) {
    s = s + a[i].substr(2)
  }
  return s
}

const current_script = scriptType.deserialize(bytesToHex(CKB.load_script(0)))
const args = hexStringArrayToHexString(current_script[2][1])
const htlcArgs = htlcArgsType.deserialize(args)

CKB.debug(`a: ${hexStringArrayToHexString(htlcArgs[0][1])}`)
CKB.debug(`b: ${hexStringArrayToHexString(htlcArgs[1][1])}`)
CKB.debug(`c: ${hexStringArrayToHexString(htlcArgs[2][1])}`)
```

----------------------------------------

TITLE: Successful UDT Transfer Transaction (Lumos, JS)
DESCRIPTION: This snippet modifies the previous transaction's output to respect the UDT sum rule (transferring a valid amount, 1,000,000), then signs and sends the transaction successfully. It demonstrates how to correctly perform a UDT transfer by updating the transaction skeleton.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_13

LANGUAGE: js
CODE:
```
txSkeleton = txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = input.cellOutput.type;
  cell.data = bytes.hexify(Uint32LE.pack(1000000));
  return outputs;
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet2.address], 3000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet2.privkey)).toArray();
signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
let txHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Add Cell Dependency for Script Execution using Lumos
DESCRIPTION: This JavaScript code adds a cell dependency to the transaction skeleton. This dependency points to the cell where the script binary was previously deployed (identified by its transaction hash `carrotTxHash` and output index "0x0"). The `depType` is set to "code", which tells CKB where to find the script code needed for execution.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_9

LANGUAGE: js
CODE:
```
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0"
  },
  depType: "code"
})
```

----------------------------------------

TITLE: Representing CKB Cell Structure (JSON)
DESCRIPTION: This JSON snippet illustrates the data structure of a CKB Cell, the basic unit on the Nervos CKB blockchain. Unlike Bitcoin's UTXO, a Cell includes `capacity` (size in shannons), a mandatory `lock` script for ownership conditions, and an optional `type` script for state transitions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/ckb-vs-btc.mdx#_snippet_1

LANGUAGE: json
CODE:
```
{
  "capacity": "0x19995d0ccf", // The size of the Cell (in shannons)
  "lock": {
    // A Script that defines the ownership of the Cell
    "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
    "args": "0x0a486fb8f6fe60f76f001d6372da41be91172259",
    "hash_type": "type"
  },
  "type": null // An optional Script that defines the type of the Cell.
}
```

----------------------------------------

TITLE: Building CKB Transfer Transaction (TypeScript)
DESCRIPTION: This snippet shows the initial part of the `transfer` function implementation. It initializes a signer with the private key, gets the recipient's lock script, and builds a transaction object using `ccc.Transaction.from`. It then sets the capacity for the output cell(s) based on the transfer amount. Requires the CCC SDK.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_4

LANGUAGE: TypeScript
CODE:
```
export async function transfer(
  toAddress: string,
  amountInCKB: string,
  signerPrivateKey: string
): Promise<string> {
  const signer = new ccc.SignerCkbPrivateKey(cccClient, signerPrivateKey);
  const { script: toLock } = await ccc.Address.fromString(toAddress, cccClient);

  // Build the full transaction to estimate the fee
  const tx = ccc.Transaction.from({
    outputs: [{ lock: toLock }],
    outputsData: [],
  });

  // CCC transactions are easy to be edited
  tx.outputs.forEach((output, i) => {
    if (output.capacity > ccc.fixedPointFrom(amountInCKB)) {
      alert(`Insufficient capacity at output ${i} to store data`);
      return;
    }
    output.capacity = ccc.fixedPointFrom(amountInCKB);
  });

  // ....
}
```

----------------------------------------

TITLE: Example CKB Cell Structure (JSON)
DESCRIPTION: Provides a concrete JSON example of a CKB Cell, showing typical values for capacity, lock script (with code_hash, args, hash_type), and a null type script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/cell.md#_snippet_1

LANGUAGE: json
CODE:
```
{
  "capacity": "0x19995d0ccf",
  "lock": {
    "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
    "args": "0x0a486fb8f6fe60f76f001d6372da41be91172259",
    "hash_type": "type"
  },
  "type": null
}
```

----------------------------------------

TITLE: Validating Type-ID Script in CKB
DESCRIPTION: This Rust code defines functions to check for the presence of Type-ID cells, locate the first Type-ID output cell, and validate a given Type-ID hash based on the transaction's first input and the output cell index, adhering to CKB's Type-ID generation rules. It requires the `ckb_std` and `blake2b_ref` crates.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/type-id.mdx#_snippet_2

LANGUAGE: Rust
CODE:
```
use alloc::vec::Vec;
use blake2b_ref::Blake2bBuilder;
use ckb_std::{
    ckb_constants::Source,
    ckb_types::prelude::Entity,
    debug,
    error::SysError,
    high_level::{load_cell_type_hash, load_input, load_script_hash},
    syscalls::load_cell,
};

use super::Error;

pub fn has_type_id_cell(index: usize, source: Source) -> bool {
    let mut buf = Vec::new();
    match load_cell(&mut buf, 0, index, source) {
        Ok(_) => true,
        Err(e) => {
            // just confirm cell presence, no data needed
            if let SysError::LengthNotEnough(_) = e {
                return true;
            }
            false
        }
    }
}

fn locate_first_type_id_output_index() -> Result<usize, Error> {
    let current_script_hash = load_script_hash()?;

    let mut i = 0;
    loop {
        let type_hash = load_cell_type_hash(i, Source::Output)?;

        if type_hash == Some(current_script_hash) {
            break;
        }
        i += 1
    }
    Ok(i)
}

/// Given a 32-byte type id, this function validates if
/// current transaction confronts to the type ID rules.
pub fn validate_type_id(type_id: [u8; 32]) -> Result<(), Error> {
    if has_type_id_cell(1, Source::GroupInput) || has_type_id_cell(1, Source::GroupOutput) {
        debug!("There can only be at most one input and at most one output type ID cell!");
        return Err(Error::TooManyTypeIdCell);
    }

    if !has_type_id_cell(0, Source::GroupInput) {
        // We are creating a new type ID cell here. Additional checkings are needed to ensure the type ID is legit.
        let index = locate_first_type_id_output_index()?;
        // The type ID is calculated as the blake2b (with CKB's personalization) of
        // the first CellInput in current transaction, and the created output cell
        // index(in 64-bit little endian unsigned integer).
        let input = load_input(0, Source::Input)?;
        let mut blake2b = Blake2bBuilder::new(32)
            .personal(b"ckb-default-hash")
            .build();
        blake2b.update(input.as_slice());
        blake2b.update(&index.to_le_bytes());
        let mut ret = [0; 32];
        blake2b.finalize(&mut ret);

        if ret != type_id {
            debug!("Invalid type ID!");
            return Err(Error::TypeIdNotMatch);
        }
    }
    Ok(())
}
```

----------------------------------------

TITLE: CKB Transaction Structure JSON
DESCRIPTION: Defines the data structure of a CKB transaction, including version, cell dependencies, header dependencies, inputs, witnesses, outputs, and output data. It shows the various fields and their types or example values.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/ckb-vs-btc.mdx#_snippet_3

LANGUAGE: JSON
CODE:
```
{
  "version": 0, // Transaction version number
  "cell_deps": [ // An array of outpoint pointing to the Cells that are dependencies of this transaction.
    {
      "out_point": { // A cell outpoint that point to the Cells used as deps.
        "tx_hash": "0xbd864a269201d7052d4eb3f753f49f7c68b8edc386afc8bb6ef3e15a05facca2",
        "index": "0x0"
      },
      "dep_type": "dep_group" // Dependency type (0 for Code, 1 for DepGroup)
    }
  ],
  "header_deps": [ // An array of hashes pointing to block headers that are dependencies of this transaction.
    "0xaa1124da6a230435298d83a12dd6c13f7d58caf7853f39cea8aad992ef88a422"
  ],
  "inputs": [ // An array of referenced Cell inputs.
    {
      "previous_output": {
        "tx_hash": "0x8389eba3ae414fb6a3019aa47583e9be36d096c55ab2e00ec49bdb012c24844d",
        "index": "0x1"
      },
      "since": "0x0" // Timelock feature
    }
  ],
  "witnesses": [ // Provided by transaction creator to make the execution of corresponding Lock Script success.
	  "0x55000000100000005500000055000000410000004a975e08ff99fa0001
    42ff3b86a836b43884b5b46f91b149f7cc5300e8607e633b7a29c94dc01c6616a12f62e74a1
    415f57fcc5a00e41ac2d7034e90edf4fdf800"
  ],
  "outputs": [ // An array of Cells that are used as outputs,
    {
      "capacity": "0x746a528800",
      "lock": {
        "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
        "args": "0x56008385085341a6ed68decfabb3ba1f3eea7b68",
        "hash_type": "type"
      },
      "type": null
    },
    {
      "capacity": "0x1561d9307e88",
      "lock": {
        "code_hash": "0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8",
        "args": "0x886d23a7858f12ebf924baaacd774a5e2cf81132",
        "hash_type": "type"
      },
      "type": null
    }
  ],
  "outputs_data": [ // An array of Cell data for each Cell output.
    "0x",
    "0x"
  ]
}
```

----------------------------------------

TITLE: Compiling JS to Duktape Bytecode and Running on CKB VM (dump_load0) - Shell
DESCRIPTION: This snippet demonstrates compiling a JavaScript file (`duktape.js`) into Duktape bytecode (`script.bin`) using `dump_bytecode`, and then executing the bytecode on the CKB VM via `runner.rb` using the `dump_load0` binary. It includes the output showing the execution command, debug information, run result, and total cycles consumed (9239414). This represents running bytecode with a specific loader.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-9.md#_snippet_13

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ ckb-duktape/build/dump_bytecode ckb-duktape-template/build/duktape.js script.bin
$ RUST_LOG=debug ./runner.rb ckb-duktape/build/dump_load0 script.bin dump0.bin
Executing: ckb-standalone-debugger/bins/target/release/ckb-debugger --tx-file tx.json --script-group-type lock -i 0 -e input -d dump0.bin
DEBUG:<unknown>: script group: Byte32(0xb5656359cbcd52cfa68e163cdd217657f0cfc533c909d13a1fdd8032f6b4f1f0) DEBUG OUTPUT: 0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947c219351b150b900e50a7039f1e448b844110927e5fd9bd30425806cb8ddff1fd970dd9a8
Run result: Ok(0)
Total cycles consumed: 9239414
Transfer cycles: 67352, running cycles: 9172062
```

----------------------------------------

TITLE: Finalizing and Sending CKB Transaction (Lumos)
DESCRIPTION: This code snippet demonstrates the final steps in building and sending a CKB transaction using Lumos. It covers adding the fee, preparing the transaction for signing, signing the transaction with a private key, sealing the transaction with signatures, and finally sending the signed transaction to the CKB RPC node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_14

LANGUAGE: JavaScript
CODE:
```
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const txHash = await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: React Component for Issuing xUDT with SUS Lock
DESCRIPTION: This React component provides a user interface and logic for issuing xUDT tokens. It guides the user through the process which involves creating a Single-Use Lock cell, an owner cell locked by the SUS, and finally the transaction that mints the xUDT and creates the xUDT info cell, consuming the SUS and owner cells. It utilizes the @ckb-ccc/connector-react library for interacting with the CKB network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_11

LANGUAGE: tsx
CODE:
```
"use client";\n\nimport { useState } from "react";\nimport { TextInput } from "@/src/components/Input";\nimport { Button } from "@/src/components/Button";\nimport { ccc } from "@ckb-ccc/connector-react";\nimport { tokenInfoToBytes, useGetExplorerLink } from "@/src/utils";\nimport { Message } from "@/src/components/Message";\nimport React from "react";\nimport { useApp } from "@/src/context";\nimport { ButtonsPanel } from "@/src/components/ButtonsPanel";\nimport Link from "next/link";\n\nexport default function IssueXUdtSul() {\n  const { signer, createSender } = useApp();\n  const { log, error } = createSender("Issue xUDT (SUS)");\n\n  const { explorerTransaction } = useGetExplorerLink();\n\n  const [amount, setAmount] = useState<string>("");\n  const [decimals, setDecimals] = useState<string>("");\n  const [name, setName] = useState<string>("");\n  const [symbol, setSymbol] = useState<string>("");\n\n  return (\n    <>\n      <div className="flex w-full flex-col items-stretch">\n        <Message title="Hint" type="info">\n          You will need to sign two or three transactions.\n          <br />\n          Learn more on{" "}\n          <Link\n            className="underline"\n            href="https://talk.nervos.org/t/en-cn-misc-single-use-seals/8279"\n            target="_blank"\n          >\n            [EN/CN] Misc: Single-Use-Seals - 杂谈：一次性密封\n          </Link>\n        </Message>\n\n        <TextInput\n          label="Amount"\n          placeholder="Amount to issue"\n          state={[amount, setAmount]}\n        />\n        <TextInput\n          label="Decimals"\n          placeholder="Decimals of the token"\n          state={[decimals, setDecimals]}\n        />\n        <TextInput\n          label="Symbol"\n          placeholder="Symbol of the token"\n          state={[symbol, setSymbol]}\n        />\n        <TextInput\n          label="Name"\n          placeholder="Name of the token, same as symbol if empty"\n          state={[name, setName]}\n        />\n\n        <ButtonsPanel>\n          <Button\n            className="self-center"\n            onClick={async () => {\n              if (!signer) {\n                return;\n              }\n              if (decimals === "" || symbol === "") {\n                error("Invalid token info");\n                return;\n              }\n\n              const { script } = await signer.getRecommendedAddressObj();\n\n              const susTx = ccc.Transaction.from({\n                outputs: [\n                  {\n                    lock: script,\n                  },\n                ],\n              });\n              await susTx.completeInputsByCapacity(signer);\n              await susTx.completeFeeBy(signer);\n              const susTxHash = await signer.sendTransaction(susTx);\n              log("Transaction sent:", explorerTransaction(susTxHash));\n              await signer.client.cache.markUnusable({\n                txHash: susTxHash,\n                index: 0,\n              });\n\n              const singleUseLock = await ccc.Script.fromKnownScript(\n                signer.client,\n                ccc.KnownScript.SingleUseLock,\n                ccc.OutPoint.from({\n                  txHash: susTxHash,\n                  index: 0,\n                }).toBytes()\n              );\n              const lockTx = ccc.Transaction.from({\n                outputs: [\n                  // Owner cell\n                  {\n                    lock: singleUseLock,\n                  },\n                ],\n              });\n              await lockTx.completeInputsByCapacity(signer);\n              await lockTx.completeFeeBy(signer);\n              const lockTxHash = await signer.sendTransaction(lockTx);\n              log("Transaction sent:", explorerTransaction(lockTxHash));\n\n              const mintTx = ccc.Transaction.from({\n                inputs: [\n                  // SUS\n                  {\n                    previousOutput: {\n                      txHash: susTxHash,\n                      index: 0,\n                    },\n                  },\n                  // Owner cell\n                  {\n                    previousOutput: {\n                      txHash: lockTxHash,\n                      index: 0,\n                    },\n                  },\n                ],\n                outputs: [\n                  // Issued xUDT\n                  {\n                    lock: script,\n                    type: await ccc.Script.fromKnownScript(\n                      signer.client,\n                      ccc.KnownScript.XUdt,\n                      singleUseLock.hash()\n                    ),\n                  },\n                  // xUDT Info\n                  {\n                    lock: script,\n                    type: await ccc.Script.fromKnownScript(\n                      signer.client,\n                      ccc.KnownScript.UniqueType,\n                      "00".repeat(32)\n                    ),\n                  },\n                ],
          
```

----------------------------------------

TITLE: Generating CKB Accounts from Mnemonic in React (TSX)
DESCRIPTION: This snippet defines a React functional component that handles mnemonic input, validation, HD key derivation using BIP39 and BIP32, generation of multiple CKB accounts (public key, private key, derivation path, address), encryption of the master key to a keystore, and rendering the UI with input fields and action buttons. It depends on `@ckb-ccc/connector-react`, `@scure/bip39`, `@scure/bip32`, and React hooks.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_27

LANGUAGE: tsx
CODE:
```
"use client";

import { ccc } from "@ckb-ccc/connector-react";
import React, { useCallback, useEffect, useMemo, useState } from "react";
import { Button } from "@/src/components/Button";
import { TextInput } from "@/src/components/Input";
import * as bip39 from "@scure/bip39";
import { wordlist } from "@scure/bip39/wordlists/english";
import { HDKey } from "@scure/bip32";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function Mnemonic() {
  const { client } = ccc.useCcc();
  const { createSender } = useApp();
  const { log } = createSender("Mnemonic");

  const [mnemonic, setMnemonic] = useState<string>("");
  const [password, setPassword] = useState<string>("");
  const [countStr, setCountStr] = useState<string>("10");
  const [accounts, setAccount] = useState<
    {
      publicKey: string;
      privateKey: string;
      address: string;
      path: string;
    }[]
  >([]);
  const isValid = useMemo(
    () => bip39.validateMnemonic(mnemonic, wordlist),
    [mnemonic],
  );

  const moreAccounts = useCallback(async () => {
    const count = parseInt(countStr, 10);
    const seed = await bip39.mnemonicToSeed(mnemonic);
    const hdKey = HDKey.fromMasterSeed(seed);
    setAccount((accounts) => [
      ...accounts,
      ...Array.from(new Array(count), (_, i) => {
        const path = `m/44'/309'/0'/0/${i + accounts.length}`;
        const derivedKey = hdKey.derive(path);
        return {
          publicKey: ccc.hexFrom(derivedKey.publicKey!),
          privateKey: ccc.hexFrom(derivedKey.privateKey!),
          path,
          address: "",
        };
      }),
    ]);
  }, [countStr, mnemonic]);

  useEffect(() => {
    setAccount([]);
    if (isValid) {
      moreAccounts();
    }
    // eslint-disable-next-line react-hooks/exhaustive-deps
  }, [mnemonic]);

  useEffect(() => {
    (async () => {
      let modified = false;
      const newAccounts = await Promise.all(
        accounts.map(async (acc) => {
          const address = await new ccc.SignerCkbPublicKey(
            client,
            acc.publicKey,
          ).getRecommendedAddress();
          if (address !== acc.address) {
            modified = true;
          }
          acc.address = address;
          return acc;
        }),
      );
      if (modified) {
        setAccount(newAccounts);
      }
    })();
  }, [client, accounts]);

  return (
    <div className="mb-1 flex w-9/12 flex-col items-stretch">
      <TextInput
        label="Mnemonic"
        placeholder="Mnemonic"
        state={[mnemonic, setMnemonic]}
      />
      <TextInput
        label="Accounts count"
        placeholder="Accounts count"
        state={[countStr, setCountStr]}
      />
      <TextInput
        label="Password"
        placeholder="Set password for Keystore"
        state={[password, setPassword]}
      />
      {accounts.length !== 0 ? (
        <div className="mt-1 w-full overflow-scroll whitespace-nowrap bg-white">
          <p>path, address, private key</p>
          {accounts.map(({ privateKey, address, path }) => (
            <p key={path}>
              {path}, {address}, {privateKey}
            </p>
          ))}
        </div>
      ) : undefined}
      <ButtonsPanel>
        <Button
          onClick={() => {
            setMnemonic(bip39.generateMnemonic(wordlist));
          }}
        >
          Random Mnemonic
        </Button>
        <Button
          className="ml-2"
          onClick={moreAccounts}
          disabled={!isValid || Number.isNaN(parseInt(countStr, 10))}
        >
          More accounts
        </Button>
        <Button
          className="ml-2"
          onClick={async () => {
            const seed = await bip39.mnemonicToSeed(mnemonic);
            const hdKey = HDKey.fromMasterSeed(seed);
            log(
              JSON.stringify(
                await ccc.keystoreEncrypt(
                  hdKey.privateKey!,
                  hdKey.chainCode!,
                  password,
                ),
              ),
            );
          }}
          disabled={!isValid}
        >
          To Keystore
        </Button>
        {accounts.length !== 0 ? (
          <Button
            as="a"
            className="ml-2"
            href={`data:application/octet-stream,path%2C%20address%2C%20private%20key%0A${accounts
              .map(({ privateKey, address, path }) =>
                encodeURIComponent(`${path}, ${address}, ${privateKey}`),
              )
              .join("\n")}`}
            download={`ckb_accounts_${Date.now()}.csv`}
          >
            Save as CSV
          </Button>
        ) : undefined}
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: OmniLockWitnessLock Structure - Molecule
DESCRIPTION: Defines the structure required in the lock field of the WitnessArgs when unlocking an Omnilock. It uses Molecule syntax to specify the `OmniLockWitnessLock` table, including optional signature, identity, and preimage fields.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_2

LANGUAGE: Molecule
CODE:
```
import xudt_rce;

array Auth[byte; 21];

table Identity {
    identity: Auth,
    proofs: SmtProofEntryVec,
}
option IdentityOpt (Identity);

// the data structure used in lock field of witness
table OmniLockWitnessLock {
    signature: BytesOpt,
    omni_identity: IdentityOpt,
    preimage: BytesOpt,
}
```

----------------------------------------

TITLE: React Component for CKB Token Transfer (TSX)
DESCRIPTION: This TSX code defines a React functional component that provides a UI for transferring CKB tokens. It utilizes the `@ckb-ccc/connector-react` library for interacting with the CKB blockchain, including address validation, transaction building, input completion, fee calculation, signing, and sending. The component manages state for the recipient address(es), amount, and optional output data, and includes buttons for calculating the maximum transferable amount and initiating the transfer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_9

LANGUAGE: tsx
CODE:
```
"use client";

import React, { useState } from "react";
import { TextInput } from "@/src/components/Input";
import { Button } from "@/src/components/Button";
import { Textarea } from "@/src/components/Textarea";
import { ccc } from "@ckb-ccc/connector-react";
import { bytesFromAnyString, useGetExplorerLink } from "@/src/utils";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function Transfer() {
  const { signer, createSender } = useApp();
  const { log, error } = createSender("Transfer");
  const { explorerTransaction } = useGetExplorerLink();

  const [transferTo, setTransferTo] = useState<string>("");
  const [amount, setAmount] = useState<string>("");
  const [data, setData] = useState<string>("");

  return (
    <div className="flex w-full flex-col items-stretch">
      <Textarea
        label="Address"
        placeholder="Addresses to transfer to, separated by lines"
        state={[transferTo, setTransferTo]}
      />
      <TextInput
        label="Amount"
        placeholder="Amount to transfer for each"
        state={[amount, setAmount]}
      />
      <Textarea
        label="Output Data(Options)"
        state={[data, setData]}
        placeholder="Leave empty if you don't know what this is. Data in the first output. Hex string will be parsed."
      />
      <ButtonsPanel>
        <Button
          variant="info"
          onClick={async () => {
            if (!signer) {
              return;
            }
            if (transferTo.split("\n").length !== 1) {
              error("Only one destination is allowed for max amount");
              return;
            }

            log("Calculating the max amount...");
            // Verify destination address
            const { script: toLock } = await ccc.Address.fromString(
              transferTo,
              signer.client
            );

            // Build the full transaction to estimate the fee
            const tx = ccc.Transaction.from({
              outputs: [{ lock: toLock }],
              outputsData: [bytesFromAnyString(data)],
            });

            // Complete missing parts for transaction
            await tx.completeInputsAll(signer);

            // Change all balance to the first output
            await tx.completeFeeChangeToOutput(signer, 0, 2000);
            const amount = ccc.fixedPointToString(tx.outputs[0].capacity);
            log("You can transfer at most", amount, "CKB");
            setAmount(amount);
          }}
        >
          Max Amount
        </Button>
        <Button
          className="ml-2"
          onClick={async () => {
            if (!signer) {
              return;
            }
            // Verify destination addresses
            const toAddresses = await Promise.all(
              transferTo
                .split("\n")
                .map((addr) => ccc.Address.fromString(addr, signer.client))
            );

            const tx = ccc.Transaction.from({
              outputs: toAddresses.map(({ script }) => ({ lock: script })),
              outputsData: [bytesFromAnyString(data)],
            });

            // CCC transactions are easy to be edited
            tx.outputs.forEach((output, i) => {
              if (output.capacity > ccc.fixedPointFrom(amount)) {
                error(`Insufficient capacity at output ${i} to store data`);
                return;
              }
              output.capacity = ccc.fixedPointFrom(amount);
            });

            // Complete missing parts for transaction
            await tx.completeInputsByCapacity(signer);
            await tx.completeFeeBy(signer, 2000);

            // Sign and send the transaction
            const txHash = await signer.sendTransaction(tx);
            log("Transaction sent:", explorerTransaction(txHash));
            await signer.client.waitTransaction(txHash);
            log("Transaction committed:", explorerTransaction(txHash));
          }}
        >
          Transfer
        </Button>
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Deploy Script Binary as Cell Data using Lumos
DESCRIPTION: This JavaScript code demonstrates how to deploy the compiled script binary (`carrot`) to the CKB blockchain. It reads the binary file, creates a transaction skeleton, transfers capacity to a new cell, updates the output cell to include the script binary as its data, pays the transaction fee, prepares signing entries, signs the transaction with the wallet's private key, and sends it to the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_5

LANGUAGE: js
CODE:
```
> const fs = require("fs");
> const data = fs.readFileSync("carrot");
> data.byteLength
7744
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address], wallet2.address, "8000" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address], 1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const carrotTxHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Test Deployed CKB Script using Lumos SDK
DESCRIPTION: This JavaScript code snippet uses the Lumos SDK to create a transaction that tests the previously deployed CKB script. It calculates the data hash of the deployed script, defines the script as a type script, creates a transaction skeleton, transfers funds, sets the output cell's type script to the deployed script, adds the script's cell as a cell dependency, pays the fee, prepares signing entries, signs the transaction, and sends it.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_3

LANGUAGE: JavaScript
CODE:
```
> const carrotDataHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
> const carrotTypeScript =  {
  codeHash: carrotDataHash,
  hashType: "data",
  args: "0x"
};

> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"100" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  return outputs;
});
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0"
  },
  depType: "code"
})
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const txHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Molecule Schema for Transaction Hash
DESCRIPTION: This Molecule schema defines the structure of a transaction in CKB. The transaction hash is generated by serializing the `raw` field of this structure and feeding it to the ckbhash function.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/glossary.md#_snippet_18

LANGUAGE: Schema
CODE:
```
table Transaction {
    raw:            RawTransaction,
    witnesses:      BytesVec,
}
```

----------------------------------------

TITLE: Query Transaction State with JSON-RPC Request
DESCRIPTION: Example JSON-RPC request payload for the `get_transaction` method. It requires the transaction hash as a parameter to retrieve the transaction details and its current status on the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-query-tx-state.mdx#_snippet_0

LANGUAGE: json
CODE:
```
{
  "id": 42,
  "jsonrpc": "2.0",
  "method": "get_transaction",
  "params": [
    "0xa0ef4eb5f4ceeb08a4c8524d84c5da95dce2f608e0ca2ec8091191b0f330c6e3"
  ]
}
```

----------------------------------------

TITLE: Creating HTLC Cell Transaction (JavaScript)
DESCRIPTION: This snippet demonstrates the process of constructing and sending a transaction to create an HTLC (Hashed Timelock Contract) cell on the CKB network. It involves deriving the lock hash from a private key, loading available cells, calculating capacities and fees, serializing HTLC arguments using Molecule, building the transaction structure with cell dependencies, inputs, outputs (including the HTLC cell and change cell), and witnesses, signing the transaction, and finally sending it to the CKB node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_20

LANGUAGE: JavaScript
CODE:
```
  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const htlcCellCapacity = 200000000000n

  const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
  const htlcArgsType = new Molecule(
    customSchema.declarations.find(d => d.name == "HtlcArgs"))
  const htlcScriptArgs = htlcArgsType.serialize([
    ['a', hexStringToHexStringArray(lockHashA)],
    ['b', hexStringToHexStringArray(lockHashB)],
    ['hash', hexStringToHexStringArray('0x' + crc32('i am a secret'))]
  ])

  const transaction = {
    version: '0x0',
    cellDeps: [
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs: [
      {
        lock: {
          codeHash: utils.bytesToHex(duktapeHash),
          hashType: 'data',
          args: htlcScriptArgs
        },
        type: null,
        capacity: '0x' + htlcCellCapacity.toString(16)
      },
      {
        lock: lockScript,
        type: null,
        capacity: '0x' + (totalCapacity - fee - htlcCellCapacity).toString(16)
      }
    ],
    witnesses: [
      {
        lock: '',
        inputType: '',
        outputType: ''
      }
    ],
    outputsData: [
      '0x',
      '0x'
    ]
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)

  const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

  console.log(`Transaction hash: ${txHash}`)
  fs.writeFileSync('create_htlc_cell_result.txt', txHash)
}

run()
```

----------------------------------------

TITLE: Building and Testing CKB Transaction with Custom Script (Lumos JS)
DESCRIPTION: Shows how to build a transaction skeleton, perform a transfer, modify an output cell to include a custom type script (`carrotTypeScript`) and data, add a cell dependency for the script code, pay fees, prepare signing entries, sign the transaction, and send it. This example specifically tests a script that rejects transactions with "carrot" in cell data, resulting in a transaction verification error. Requires `indexer`, `wallet`, `wallet2`, `carrotTypeScript`, and `carrotTxHash`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_12

LANGUAGE: JavaScript
CODE:
```
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"400" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  cell.data = "0x" + Buffer.from("carrot123", "utf8").toString("hex");
  return outputs;
});
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0",
  },
  depType: "code",
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
> await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Deploying Smart Contracts to Devnet with offckb (Shell)
DESCRIPTION: Navigates into the frontend project directory and executes the `offckb deploy` command targeting the devnet. The `-t` flag is included, which might indicate a specific test or target configuration.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-lock/README.md#_snippet_0

LANGUAGE: sh
CODE:
```
cd frontend
offckb deploy -t --network devnet
```

----------------------------------------

TITLE: Group Inputs by Script Hash in Python
DESCRIPTION: This Python helper function demonstrates how to group transaction inputs based on the hash of their lock script. It iterates through the inputs, calculates the Blake256 hash of each input's serialized lock script, and stores the input index under the corresponding hash key in a dictionary. It requires `defaultdict` from the `collections` module, a `blake256` hashing function, and a `serialize` function for the lock script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-sign-a-tx.mdx#_snippet_1

LANGUAGE: Python
CODE:
```
def compute_input_groups(inputs):
		groups = defaultdict(list)
		for i, input in enumerate(inputs):
				script_hash = blake256(serialize(input.lock))
				groups[script_hash].append(i)

		return groups.values()
```

----------------------------------------

TITLE: Complete Transaction Inputs and Fee (TypeScript)
DESCRIPTION: Demonstrates how to use the CCC library to automatically complete the transaction by selecting necessary input Cells to cover the output capacity and the transaction fee. This step prepares the transaction for signing and broadcasting.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/write-message.mdx#_snippet_3

LANGUAGE: typescript
CODE:
```
// Complete missing parts for transaction
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);
```

----------------------------------------

TITLE: Implementing CKB HTLC Script Logic - JavaScript
DESCRIPTION: This JavaScript code implements the core logic for a CKB HTLC contract. It uses the Molecule library to deserialize script arguments and witness data based on predefined schemas. The script handles two paths: one based on revealing a secret string (verified using CRC32) and another based on a timeout period (verified by comparing block numbers from headers). It interacts with the CKB environment to load script, witness, header, and cell data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_17

LANGUAGE: javascript
CODE:
```
const { Molecule } = require('molecule-javascript')
const schema = require('../schema/blockchain-combined.json')

const names = schema.declarations.map(declaration => declaration.name)
const scriptTypeIndex = names.indexOf('Script')
const scriptType = new Molecule(schema.declarations[scriptTypeIndex])

// Write your script logic here.
const customSchema = require('./htlc-combined.json')
const customNames = customSchema.declarations.map(d => d.name)

const htlcArgsIndex = customNames.indexOf('HtlcArgs')
const htlcArgsType = new Molecule(customSchema.declarations[htlcArgsIndex])

function bytesToHex(b) {
  return "0x" + Array.prototype.map.call(
    new Uint8Array(b),
    function(x) {
      return ('00' + x.toString(16)).slice(-2)
    }
  ).join('')
}

function hexStringArrayToString(a) {
  let s = "";
  for (let i = 0; i < a.length; i++) {
    s = s + String.fromCharCode(parseInt(a[i]))
  }
  return s
}

function hexStringArrayToHexString(a) {
  let s = "0x";
  for (let i = 0; i < a.length; i++) {
    s = s + a[i].substr(2)
  }
  return s
}

function parseLittleEndianHexStringArray(a) {
  let v = 0
  const l = a.length
  for (let i = 0; i < l; i++) {
    v = (v << 8) | parseInt(a[l - i - 1])
  }
  return v
}

const current_script = scriptType.deserialize(bytesToHex(CKB.load_script(0)))
const args = hexStringArrayToHexString(current_script[2][1])
const htlcArgs = htlcArgsType.deserialize(args)

// Load and parse witness data using the same method as above
const htlcWitnessIndex = customNames.indexOf('HtlcWitness')
const htlcWitnessType = new Molecule(customSchema.declarations[htlcWitnessIndex])

const rawWitness = CKB.load_witness(0, 0, CKB.SOURCE.GROUP_INPUT)
if (typeof rawWitness === 'number') {
  throw new Error(`Invalid response when loading witness: ${rawWitness}`)
}
const htlcWitness = htlcWitnessType.deserialize(bytesToHex(rawWitness))

let lockHashToMatch;
if (htlcWitness[0][1].length > 0) {
  // Test secret string hash
  const crc32 = require('crc32')
  const hash = '0x' + crc32(hexStringArrayToString(htlcWitness[0][1]))
  if (hash !== hexStringArrayToHexString(htlcArgs[2][1])) {
    throw new Error(`Invalid secret string!`)
  }
  lockHashToMatch = hexStringArrayToHexString(htlcArgs[0][1])
} else {
  // Test header block
  const headerTypeIndex = names.indexOf('Header')
  const headerType = new Molecule(schema.declarations[headerTypeIndex])

  // Load header for current input first
  const rawInputHeader = CKB.load_header(0, 0, CKB.SOURCE.GROUP_INPUT)
  if (typeof rawWitness === 'number') {
    throw new Error(`Invalid response when loading input header: ${rawInputHeader}`)
  }
  const inputHeader = headerType.deserialize(bytesToHex(rawInputHeader))
  const inputHeaderNumber = parseLittleEndianHexStringArray(inputHeader[0][1][3][1])

  const targetHeaderIndex = parseLittleEndianHexStringArray(htlcWitness[1][1])
  const rawTargetHeader = CKB.load_header(0, targetHeaderIndex,
                                          CKB.SOURCE.HEADER_DEP)
  if (typeof rawTargetHeader === 'number') {
    throw new Error(`Invalid response when loading target header: ${rawTargetHeader}`)
  }
  const targetHeader = headerType.deserialize(bytesToHex(rawTargetHeader))
  const targetHeaderNumber = parseLittleEndianHexStringArray(targetHeader[0][1][3][1])

  if (targetHeaderNumber < inputHeaderNumber + 100) {
    throw new Error(`Timeout period has not reached!`)
  }
  lockHashToMatch = hexStringArrayToHexString(htlcArgs[1][1])
}

// Now we know which lock hash to test against, we look for an input cell
// with the specified lock hash
let i = 0
while (true) {
  const rawHash = CKB.load_cell_by_field(0, i, CKB.SOURCE.INPUT, CKB.CELL.LOCK_HASH)
  if (rawHash == CKB.CODE.INDEX_OUT_OF_BOUND) {
    throw new Error(`Cannot find input cell using lock hash ${lockHashToMatch}`)
  }
  if (typeof rawHash === 'number') {
    throw new Error(`Invalid response when loading input cell: ${rawHash}`)
  }
  if (bytesToHex(rawHash) == lockHashToMatch) {
    break
  }
  i += 1
}
```

----------------------------------------

TITLE: Minimal CKB Script (Always Success) - Rust
DESCRIPTION: This is the simplest possible CKB script in Rust. It always returns 0, indicating success. While not secure for production, it's useful for testing in development environments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_0

LANGUAGE: Rust
CODE:
```
pub fn program_entry() -> i8 {
    0
}
```

----------------------------------------

TITLE: Rust Script Struct Definition
DESCRIPTION: This Rust code block shows the definition of the `Script` struct in CKB. It contains fields for `code_hash` (the Blake2b hash of the script binary), `hash_type` (specifying how the `code_hash` should be interpreted), and `args` (optional arguments passed to the script).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_7

LANGUAGE: rust
CODE:
```
pub struct Script {
    pub code_hash: H256,
    pub hash_type: ScriptHashType,
    pub args: JsonBytes,
}
```

----------------------------------------

TITLE: CKB Script Data Structure (Rust)
DESCRIPTION: Defines the `Script` struct in Rust, which represents a CKB script. It includes fields for `code_hash` (a 256-bit hash), `hash_type` (specifying how the `code_hash` is interpreted), and `args` (arbitrary bytes passed to the script). This struct is a fundamental building block for defining cell lock and type scripts on CKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_7

LANGUAGE: rust
CODE:
```
pub struct Script {
    pub code_hash: H256,
    pub hash_type: ScriptHashType,
    pub args: JsonBytes,
}
```

----------------------------------------

TITLE: Structure of a CKB Script
DESCRIPTION: Defines the structure of the CKB Script data type, listing its required fields: code_hash (hash of the RISC-V binary), args (script input arguments), and hash_type (interpretation of the code hash).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/script.md#_snippet_0

LANGUAGE: bash
CODE:
```
Script: {
  code_hash: HexString
  args: HexString
  hash_type: Uint8, there are 4 allowed values: {0: "data", 1: "type", 2: "data1", 4: "data2"}
}
```

----------------------------------------

TITLE: Getting Account Balance by Address (TypeScript)
DESCRIPTION: This function queries the balance of a CKB account given its address. It converts the address string to a CCC Address object and then uses the CCC SDK client to fetch the balance associated with the account's Lock Script. The balance is returned in Shannon units.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_2

LANGUAGE: TypeScript
CODE:
```
export async function capacityOf(address: string): Promise<bigint> {
  const addr = await ccc.Address.fromString(address, cccClient);
  let balance = await cccClient.getBalance([addr.script]);
  return balance;
}
```

----------------------------------------

TITLE: Creating Minimal CKB Script C
DESCRIPTION: This snippet shows the most basic CKB script written in C. It defines a standard `main` function that takes command-line arguments and simply returns 0. In the CKB VM, a return code of 0 signifies successful script execution, making this a script that always passes validation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_1

LANGUAGE: C
CODE:
```
int main(int argc, char* argv[])
{
  return 0;
}
```

----------------------------------------

TITLE: Using CCC Molecule Built-in Types (JavaScript)
DESCRIPTION: Provides examples of encoding and decoding common built-in types available in the CCC Molecule module, including boolean, fixed-size byte arrays (Byte16, Byte32), and unsigned integers (Uint8, Uint128LE).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/ccc-molecule.mdx#_snippet_2

LANGUAGE: JavaScript
CODE:
```
// CCC built-in types
console.log(ccc.mol.Bool.decode("0x01")); // true
console.log(ccc.mol.Bool.encode(true).toString()); // 1

// All kinds of bytes
console.log(ccc.mol.Byte16.encode("0x12345678901234567890123456789012"));
console.log(ccc.mol.Byte16.decode(ccc.bytesFrom([18,52,86,120,144,18,52,86,120,144,18,52,86,120,144,18])));
console.log(ccc.mol.Byte32.encode("0x1234567890123456789012345678901212345678901234567890123456789012"));
console.log(ccc.mol.Byte32.decode(ccc.bytesFrom([18,52,86,120,144,18,52,86,120,144,18,52,86,120,144,18,18,52,86,120,144,18,52,86,120,144,18,52,86,120,144,18])));

// All kinds of numbers
console.log(ccc.mol.Uint8.encode(1).toString()); // 0x01
console.log(ccc.mol.Uint8.decode("0x01")); // 1
console.log(ccc.mol.Uint128LE.decode("0x01000000000000000000000000000000")); // 1
console.log(ccc.mol.Uint128LE.encode(1).toString()); // 0x01000000000000000000000000000000
```

----------------------------------------

TITLE: Query Transaction State with Lumos SDK
DESCRIPTION: Example JavaScript code using the Lumos SDK to interact with the CKB RPC. It demonstrates how to use `rpc.sendTransaction` to broadcast a transaction and then `rpc.getTransaction` to query its state using the returned transaction hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-query-tx-state.mdx#_snippet_2

LANGUAGE: javascript
CODE:
```
const txHash = await rpc.sendTransaction(tx, "passthrough");
const state = await rpc.getTransaction(txHash);
```

----------------------------------------

TITLE: Debug Full CKB Transaction with offckb
DESCRIPTION: Use this command to debug an entire CKB transaction by providing its hash. The tool verifies all scripts and outputs detailed execution information, including cycle consumption for each script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_21

LANGUAGE: Shell
CODE:
```
offckb debug <transaction-hash>
```

----------------------------------------

TITLE: Compose and Send CKB Transaction with CCC
DESCRIPTION: Illustrates how to compose a simple CKB transfer transaction using the `ccc.Transaction` object, complete inputs and fee, and send it using a signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_6

LANGUAGE: tsx
CODE:
```
const tx = ccc.Transaction.from({
  outputs: [{ lock: toLock, capacity: ccc.fixedPointFrom(amount) }],
});

// Instruct CCC to complete the transaction
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000); // Specify the transaction fee rate
const txHash = await signer.sendTransaction(tx); // Send and get the transaction hash
```

----------------------------------------

TITLE: Initialize CKB RPC Client (Rust)
DESCRIPTION: Demonstrates how to import the `CkbRpcClient` and create an instance connected to a specified CKB node URL (Testnet example shown). Includes example URLs for different networks.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/rust.mdx#_snippet_5

LANGUAGE: Rust
CODE:
```
use ckb_sdk::rpc::CkbRpcClient;

let testnet_url = "https://testnet.ckb.dev"; // Testnet
let devnet_url = "http://127.0.0.1:8114"; // Devnet
let mainnet_url = "https://mainnet.ckb.dev/rpc"; // Mainnet

// Connect to Testnet
let mut ckb_client = CkbRpcClient::new(testnet_url);
```

----------------------------------------

TITLE: Import and Use Deployed Scripts in Frontend
DESCRIPTION: Example TypeScript code showing how to import the deployed script details from the generated `offckb.config.ts` file and construct `CellDep` and `Script` objects for use in a frontend dApp.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_22

LANGUAGE: typescript
CODE:
```
import offckb from "offckb.config";

const myScriptDeps: CellDep[] = offCKB.myScripts["YOUR_SCRIPT_NAME"]!.cellDeps;
const myScript: Script = {
  codeHash: offCKB.myScripts["hash-lock"]!.codeHash,
  hashType: offCKB.myScripts["hash-lock"]!.hashType,
  args: lockArgs,
};
```

----------------------------------------

TITLE: Constructing CKB Transaction for HTLC Secret Unlock (JavaScript)
DESCRIPTION: This JavaScript code snippet demonstrates how to construct a CKB transaction to unlock an HTLC cell using the correct secret string. It includes setting up cell dependencies, inputs, outputs, and serializing the HTLC witness data with the secret using Molecule. The snippet also shows how to sign the transaction and perform a dry run or send it.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_24

LANGUAGE: JavaScript
CODE:
```
['s', stringToHexStringArray(secretString)],
    ['i', ['0x0', '0x0', '0x0', '0x0']]
  ])

  const transaction = {
    version: '0x0',
    cellDeps: [
      // Due to the requirement of load0 duktape binary, JavaScript source cell
      // should be the first one in cell deps
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x1"
        },
        depType: 'code'
      },
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x0"
        },
        depType: 'code'
      },
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs: [
      {
        lock: lockScript,
        type: null,
        capacity: '0x' + (totalCapacity + htlcCellCapacity - fee).toString(16)
      }
    ],
    witnesses: unspentCells.map(_cell => '0x'),
    outputsData: [
      '0x',
      '0x'
    ]
  }
  transaction.inputs.push({
    previousOutput: {
      txHash: htlcCellTxHash,
      index: "0x0"
    },
    since: '0x0'
  })
  transaction.witnesses[0] = {
    lock: '',
    inputType: '',
    outputType: ''
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)
  signedTransaction.witnesses.push(htlcWitness)

  if (dryrun) {
    try {
      const result = await ckb.rpc.dryRunTransaction(signedTransaction)
      console.log(`Dry run success result: ${JSON.stringify(result, null, 2)}`)
    } catch (e) {
      console.log(`Dry run failure result: ${JSON.stringify(JSON.parse(e.message), null, 2)}`)
    }
  } else {
    const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

    console.log(`Transaction hash: ${txHash}`)
    fs.writeFileSync('unlock_via_secret_string_result.txt', txHash)
  }
}

run()
```

----------------------------------------

TITLE: Creating HTLC Cell Transaction (JavaScript)
DESCRIPTION: This script demonstrates how to construct and send a transaction to create an HTLC cell on the CKB network. It calculates the lock hash, loads available cells, defines the transaction inputs and outputs, serializes the HTLC arguments using a Molecule schema, signs the transaction with a private key, and broadcasts it to the network. It includes logic for calculating capacity, fee, and handling cell dependencies.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_21

LANGUAGE: JavaScript
CODE:
```
const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const htlcCellCapacity = 200000000000n

  const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
  const htlcArgsType = new Molecule(
    customSchema.declarations.find(d => d.name == "HtlcArgs"))
  const htlcScriptArgs = htlcArgsType.serialize([
    ['a', hexStringToHexStringArray(lockHashA)],
    ['b', hexStringToHexStringArray(lockHashB)],
    ['hash', hexStringToHexStringArray('0x' + crc32('i am a secret'))]
  ])

  const transaction = {
    version: '0x0',
    cellDeps: [
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs: [
      {
        lock: {
          codeHash: utils.bytesToHex(duktapeHash),
          hashType: 'data',
          args: htlcScriptArgs
        },
        type: null,
        capacity: '0x' + htlcCellCapacity.toString(16)
      },
      {
        lock: lockScript,
        type: null,
        capacity: '0x' + (totalCapacity - fee - htlcCellCapacity).toString(16)
      }
    ],
    witnesses: [
      {
        lock: '',
        inputType: '',
        outputType: ''
      }
    ],
    outputsData: [
      '0x',
      '0x'
    ]
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)

  const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

  console.log(`Transaction hash: ${txHash}`)
  fs.writeFileSync('create_htlc_cell_result.txt', txHash)
}

run()
```

----------------------------------------

TITLE: Constructing and Sending CKB Transaction (JS)
DESCRIPTION: This JavaScript snippet demonstrates how to add an input to a CKB transaction, prepare witnesses, sign the transaction using a private key, and then either perform a dry run for validation or send the transaction to the CKB node. It includes error handling for the dry run and logging the results.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_26

LANGUAGE: JavaScript
CODE:
```
  transaction.inputs.push({
    previousOutput: {
      txHash: htlcCellTxHash,
      index: "0x0"
    },
    since: '0x0'
  })
  transaction.witnesses[0] = {
    lock: '',
    inputType: '',
    outputType: ''
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)
  signedTransaction.witnesses.push(htlcWitness)

  if (dryrun) {
    try {
      const result = await ckb.rpc.dryRunTransaction(signedTransaction)
      console.log(`Dry run success result: ${JSON.stringify(result, null, 2)}`)
    } catch (e) {
      console.log(`Dry run failure result: ${JSON.stringify(JSON.parse(e.message), null, 2)}`)
    }
  } else {
    const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

    console.log(`Transaction hash: ${txHash}`)
    fs.writeFileSync('unlock_via_timeout_result.txt', txHash)
  }
}

run()
```

----------------------------------------

TITLE: Complete, Sign, and Send CKB Transaction (DAO)
DESCRIPTION: Completes transaction inputs and fees, handles different DAO scenarios (new deposit vs. withdraw/redeem), signs the transaction, sends it to the network, and waits for confirmation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_21

LANGUAGE: TypeScript
CODE:
```
            await tx.completeInputsByCapacity(signer);
            await tx.completeFeeBy(signer);
          } else {
            if (!infos[3]) {
              error("Unexpected no found deposit info");
              return;
            }
            const [withdrawTx, withdrawHeader] = infos[3];
            if (!withdrawTx?.blockHash) {
              error("Unexpected empty redeem tx block info");
              return;
            }
            if (!depositTx.blockHash) {
              error("Unexpected empty deposit tx block info");
              return;
            }

            tx = ccc.Transaction.from({
              headerDeps: [withdrawTx.blockHash, blockHash],
              inputs: [
                {
                  previousOutput: dao.outPoint,
                  since: {
                    relative: "absolute",
                    metric: "epoch",
                    value: ccc.epochToHex(
                      getClaimEpoch(depositHeader, withdrawHeader)
                    ),
                  },
                },
              ],
              outputs: [
                {
                  lock: (await signer.getRecommendedAddressObj()).script,
                },
              ],
              witnesses: [
                ccc.WitnessArgs.from({
                  inputType: ccc.numLeToBytes(1, 8),
                }).toBytes(),
              ],
            });
            await tx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.NervosDao
            );

            await tx.completeInputsByCapacity(signer);
            await tx.completeFeeChangeToOutput(signer, 0);
            tx.outputs[0].capacity += profit;
          }

          // Sign and send the transaction
          const txHash = await signer.sendTransaction(tx);
          log("Transaction sent:", explorerTransaction(txHash));
          await signer.client.waitTransaction(txHash);
          log("Transaction committed:", explorerTransaction(txHash));
        })();
      }}
```

----------------------------------------

TITLE: Deploying and Testing HTLC Scripts (Shell)
DESCRIPTION: This comprehensive shell script sequence outlines the steps to build the HTLC script, make the runner executables runnable, deploy the duktape binary and JS scripts to the chain, create an HTLC cell, and finally test unlocking the cell using both the correct secret string (dry run success) and an invalid one (implied failure).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_29

LANGUAGE: Shell
CODE:
```
# Make sure the HTLC script is successfully built first
$ cd $TOP/htlc-template
$ npm run build
# Ensure all scripts are runnable
$ cd $TOP/htlc-runner
$ chmod +x deploy_scripts.js
$ chmod +x create_htlc_cell.js
$ chmod +x unlock_via_secret_string.js
$ chmod +x unlock_via_timeout.js

# Let's first deploy duktape binary and JS scripts
$ ./deploy_scripts.js \
    ../ckb-duktape/build/load0 \
    ../htlc-template/build/duktape.js \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/"
This method is only for demo, don't use it in production
Transaction hash: 0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e008d636b8c9154f5c296e1f4

# Let's create a HTLC cell
$ ./create_htlc_cell.js \
    ../ckb-duktape/build/load0 \
    0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e006ad0ce8eac07947 \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/" \
    0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947 \
    0xc219351b150b900e50a7039f1e448b844110927e5fd9bd30425806cb8ddff1fd
This method is only for demo, don't use it in production
Transaction hash: 0x7de8ea6b0d6cb9941e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd

# To save us the hassle of recreating cells, both unlock executables support
# a dry run mode, where we only does full transaction verification, but do not
# commit the success ones on chain.
# First let's show that we can unlock a HTLC cell given the right secret string
# and lock script
$ ./unlock_via_secret_string.js \
    0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e008d636b8c9154f5c296e1f4 \
    0x7de8ea6b0d6cb9941e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/" \
    "i am a secret" \
    true
This method is only for demo, don't use it in production
Dry run success result: {
  "cycles": "0xb1acc38"
}
```

----------------------------------------

TITLE: Start CKB Devnet with offckb
DESCRIPTION: Uses the globally installed `offckb` tool to start a local CKB development network node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/xudt/README.md#_snippet_3

LANGUAGE: Shell
CODE:
```
offckb node
```

----------------------------------------

TITLE: Defining Table Type in Molecule Schema Language (C Syntax)
DESCRIPTION: Shows the syntax for defining a table type in Molecule Schema Language. Similar to a struct, a table is a composite type with a set of named and typed fields, but it has different serialization characteristics (e.g., fields are optional).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/schema-language.mdx#_snippet_5

LANGUAGE: c
CODE:
```
table TableName {
    field_name_1: FieldType1,
    field_name_2: FieldType2,
    field_name_3: FieldType3,
}
```

----------------------------------------

TITLE: Defining CKB Script Structure in Rust
DESCRIPTION: This Rust struct defines the structure of a CKB Script object. It includes fields for `code_hash` (identifying the script code), `hash_type` (determining how the hash is calculated), and `args` (additional arguments for the script). This structure is fundamental to how scripts are represented and used on the CKB blockchain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_0

LANGUAGE: Rust
CODE:
```
pub struct Script {
    pub code_hash: H256,
    pub hash_type: ScriptHashType,
    pub args: JsonBytes,
}
```

----------------------------------------

TITLE: Preparing Transaction with Duktape Script Type using Lumos
DESCRIPTION: This JavaScript snippet uses Lumos to prepare a transaction that includes a cell whose type script points to the previously deployed duktape REPL binary (identified by its code hash and hash type 'data') and uses the assembled hexadecimal arguments. It also adds the deployed binary as a cell dependency.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_12

LANGUAGE: javascript
CODE:
```
> const duktapeReplCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
> const duktapeTypeScript = {
  codeHash: duktapeReplCodeHash,
  hashType: "data",
  args: "0x370000000c00000033000000000000001f000000434b422e6465627567282249276d2072756e6e696e6720696e204a5322290a04000000",
};
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"150" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = duktapeTypeScript;
  return outputs;
});
> txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: duktapeReplTxHash,
    index: "0x0",
  },
  depType: "code",
});
```

----------------------------------------

TITLE: Calculating Address Capacity (TypeScript)
DESCRIPTION: This asynchronous function takes a CKB address string, converts it to a `ccc.Address` object, extracts its script, and then uses `cccClient.getBalance` to sum the capacities of all Live Cells locked by that script. It returns the total capacity as a `bigint`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/simple-lock.mdx#_snippet_7

LANGUAGE: TypeScript
CODE:
```
// ...
export async function capacityOf(address: string): Promise<bigint> {
  const addr = await ccc.Address.fromString(address, cccClient);
  let balance = await cccClient.getBalance([addr.script]);
  return balance;
}
// ...
```

----------------------------------------

TITLE: Validating Proof-of-Work for Header in CKB (Pseudocode)
DESCRIPTION: This pseudocode snippet outlines the process for validating the Proof-of-Work (PoW) for a block header in Nervos CKB. It involves serializing and hashing the raw header data, concatenating the hash with the nonce, applying the Eaglesong algorithm, and comparing the resulting output against the target difficulty derived from the compact target.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/header.md#_snippet_0

LANGUAGE: Pseudocode
CODE:
```
pow_hash := ckbhash(molecule_serialize(raw))
pow_message := pow_hash || to_le(nounce)
pow_output := eaglesong(pow_message)
// for Testnet, there is another round of hash
// pow_output = ckbhash(pow_output)

from_be(pow_output) <= compact_to_target(raw.compact_target)
```

----------------------------------------

TITLE: Type ID Genesis Script Hash (Hex)
DESCRIPTION: This hexadecimal string represents the special Type Script hash used for the Type ID genesis script in CKB. It is derived from the ASCII text 'TYPE_ID'. This unique hash allows the Type ID script to reference itself recursively and serves as a fixed identifier for upgradability.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/type-id.mdx#_snippet_1

LANGUAGE: Hex
CODE:
```
0x00000000000000000000000000000000000000000000000000545950455f4944
```

----------------------------------------

TITLE: Debugging Transaction with OffCKB
DESCRIPTION: Uses the offckb debug command with a transaction hash to analyze the execution of the transaction on the Devnet, showing script run results and cycle consumption.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_24

LANGUAGE: sh
CODE:
```
offckb debug --tx-hash 0x252305141e6b7db81f7da94b098493a36b756fe9d5d4436c9d7c966882bc0b38
```

----------------------------------------

TITLE: Define AttrValue Type and Codec - JavaScript
DESCRIPTION: Defines the `AttrValue` type and its associated codec bindings in JavaScript using the CKB-CCC library. It includes functions for encoding and decoding the value to/from bytes and implements validation logic to enforce an upper limit of 100 on the numeric value.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/ccc-molecule.mdx#_snippet_4

LANGUAGE: javascript
CODE:
```
import { Bytes, bytesFrom, BytesLike, mol, NumLike } from "@ckb-ccc/core";

export type AttrValue = number;
export type AttrValueLike = NumLike;
export const AttrValueCodec: mol.Codec<AttrValueLike, AttrValue> =
  mol.Codec.from({
    byteLength: 1,
    encode: attrValueToBytes,
    decode: attrValueFromBytes,
  });

export function attrValueFrom(val: AttrValueLike): AttrValue {
  if (typeof val === "number") {
    if (val > 100) {
      throw new Error(`Invalid attr value ${val}`);
    }
    return val;
  }

  if (typeof val === "bigint") {
    if (val > BigInt(100)) {
      throw new Error(`Invalid attr value ${val}`);
    }
    return Number(val);
  }

  if (typeof val === "string") {
    const num = parseInt(val);
    if (num > 100) {
      throw new Error(`Invalid attr value ${num}`);
    }
    return num;
  }

  throw new Error(`Invalid attr value ${val}`);
}

export function attrValueToBytes(val: AttrValueLike): Bytes {
  return bytesFrom([attrValueFrom(val)]);
}

export function attrValueFromBytes(bytes: BytesLike): AttrValue {
  return attrValueFrom(bytesFrom(bytes)[0]);
}
```

----------------------------------------

TITLE: Prepare CKB Transaction JSON with Duktape and JS Script (JavaScript)
DESCRIPTION: This script reads a Duktape binary and a JavaScript script, computes their Blake2b hashes, and embeds them along with the Duktape binary content into a skeleton transaction JSON file. It then calculates the hash of the lock script defined in the generated JSON and prints a command to execute the CKB debugger with the transaction file and lock script hash. Requires `fs` and `utils` modules.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_5

LANGUAGE: JavaScript
CODE:
```
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 4) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <js script>`)
  process.exit(1)
}

const duktape_binary = fs.readFileSync(process.argv[2])
const duktape_hash = blake2b(duktape_binary)
const js_script = fs.readFileSync(process.argv[3])

const data = fs.readFileSync('skeleton.json', 'utf8').
      replace("@DUKTAPE_HASH", utils.bytesToHex(duktape_hash)).
      replace("@SCRIPT_CODE", utils.bytesToHex(js_script)).
      replace("@DUKTAPE_CODE", utils.bytesToHex(duktape_binary))

fs.writeFileSync('tx.json', data)

const resolved_tx = JSON.parse(data)
const json_lock_script = resolved_tx.mock_info.inputs[0].output.lock
const lock_script = {
  codeHash: json_lock_script.code_hash,
  hashType: json_lock_script.hash_type,
  args: json_lock_script.args
}
const lock_script_hash = blake2b(utils.hexToBytes(utils.serializeScript(lock_script)))

console.log(`../ckb-standalone-debugger/bins/target/release/ckb-debugger -g lock -h ${utils.bytesToHex(lock_script_hash)} -t tx.json`)
```

----------------------------------------

TITLE: Implementing CKB Hash Lock Script in Rust
DESCRIPTION: This Rust code defines the on-chain logic for a CKB hash lock. It loads the script arguments to get the expected hash, retrieves the preimage from the first input's witness, hashes the preimage using Blake2b-256, and compares the resulting hash with the expected hash. It returns 0 on success or a custom error code on failure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/simple-lock.mdx#_snippet_5

LANGUAGE: Rust
CODE:
```
#![no_std]
#![cfg_attr(not(test), no_main)]

#[cfg(test)]
extern crate alloc;

use ckb_hash::blake2b_256;
use ckb_std::ckb_constants::Source;

#[cfg(not(test))]
use ckb_std::default_alloc;
use ckb_std::error::SysError;
#[cfg(not(test))]
ckb_std::entry!(program_entry);
#[cfg(not(test))]
default_alloc!();

#[repr(i8)]
pub enum Error {
    IndexOutOfBound = 1,
    ItemMissing,
    LengthNotEnough,
    Encoding,
    // Add customized errors here...
    CheckError,
    UnMatch,
}

impl From<SysError> for Error {
    fn from(err: SysError) -> Self {
        match err {
            SysError::IndexOutOfBound => Self::IndexOutOfBound,
            SysError::ItemMissing => Self::ItemMissing,
            SysError::LengthNotEnough(_) => Self::LengthNotEnough,
            SysError::Encoding => Self::Encoding,
            SysError::Unknown(err_code) => panic!("unexpected sys error {}", err_code),
        }
    }
}

pub fn program_entry() -> i8 {
    ckb_std::debug!("This is a sample contract!");

    match check_hash() {
        Ok(_) => 0,
        Err(err) => err as i8,
    }
}

pub fn check_hash() -> Result<(), Error> {
    let script = ckb_std::high_level::load_script()?;
    let expect_hash = script.args().raw_data().to_vec();

    let witness_args = ckb_std::high_level::load_witness_args(0, Source::GroupInput)?;
    let preimage = witness_args
        .lock()
        .to_opt()
        .ok_or(Error::CheckError)?
        .raw_data();

    let hash = blake2b_256(preimage.as_ref());

    if hash.eq(&expect_hash.as_ref()) {
        Ok(())
    } else {
        Err(Error::UnMatch)
    }
}
```

----------------------------------------

TITLE: Initialize Lumos SDK and Wallets
DESCRIPTION: This JavaScript snippet shows the initial setup in a Node.js REPL environment using the Lumos SDK. It requires the `@ckb-lumos/lumos` package, initializes the configuration for the testnet, connects to an indexer and RPC endpoint, and defines two wallet objects with addresses and private keys.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_4

LANGUAGE: js
CODE:
```
$ node
Welcome to Node.js v20.12.0.
Type ".help" for more information.
>
> const lumos = require("@ckb-lumos/lumos");
> const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
> const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
> lumos.config.initializeConfig(lumos.config.TESTNET);
> const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6",
};
> const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}
```

----------------------------------------

TITLE: Configuring Lumos SDK for CKB Mainnet (JavaScript)
DESCRIPTION: This snippet demonstrates how to configure the Lumos SDK to connect to the CKB Mainnet. It initializes the Indexer and RPC clients using the Mainnet RPC URL and sets the Lumos configuration for the Mainnet environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/blockchain-networks.mdx#_snippet_1

LANGUAGE: JavaScript
CODE:
```
const lumos = require("@ckb-lumos/lumos");
const indexer = new lumos.Indexer("https://mainnet.ckb.dev/rpc");
const rpc = new lumos.RPC("https://mainnet.ckb.dev/rpc");
lumos.config.initializeConfig(lumos.config.MAINNET);
```

----------------------------------------

TITLE: Defining Skills and Skill Sets Molecule C
DESCRIPTION: Defines individual skills as optional types (`option`) based on `SkillLevel`, groups all possible skills into a `union` called `Skill`, and defines a dynamic list of learned skills using a `vector` called `Skills`. Imports the `common/basic_types` schema.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/example-role-playing-game.mdx#_snippet_3

LANGUAGE: c
CODE:
```
import common/basic_types;

// We define several skills.
// None means the role can learn a skill but he/she doesn't learn it.
option ArmorLight       (SkillLevel);
option ArmorHeavy       (SkillLevel);   // only Fighter can learn this
option ArmorShields     (SkillLevel);   // only Fighter can learn this
option WeaponSwords     (SkillLevel);   // only Mage can't learn this
option WeaponBows       (SkillLevel);   // only Ranger can learn this
option WeaponBlunt      (SkillLevel);
option Dodge            (SkillLevel);
option PickLocks        (SkillLevel);
option Mercantile       (SkillLevel);
option Survival         (SkillLevel);
// ... omit other skills ...

// Any skill which is defined above.
union Skill {
    ArmorLight,
    ArmorHeavy,
    ArmorShields,
    WeaponSwords,
    WeaponBows,
    WeaponBlunt,
    Dodge,
    PickLocks,
    Mercantile,
    Survival,
    // ... omit other skills ...
}

// A hero can learn several skills. The size of learned skills is dynamic.
vector Skills <Skill>;
```

----------------------------------------

TITLE: Deploy CKB Script using Lumos SDK
DESCRIPTION: This JavaScript code snippet uses the Lumos SDK to deploy the compiled CKB script (`carrot_bug`) onto the CKB testnet. It reads the script binary, creates a transaction skeleton, transfers funds, attaches the script binary as cell data, pays the fee, prepares signing entries, signs the transaction, and sends it to the RPC endpoint.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_2

LANGUAGE: JavaScript
CODE:
```
> const lumos = require("@ckb-lumos/lumos");
> const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
> const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
> lumos.config.initializeConfig(lumos.config.TESTNET);
> const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6"
};
> const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}

> const data = fs.readFileSync("carrot_bug");
> data.byteLength
19760
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"19900" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const carrotTxHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Testing CKB Transaction Verification Failure in Rust
DESCRIPTION: This Rust unit test function demonstrates how to build a CKB transaction programmatically and verify it within a test environment. It specifically tests a scenario where the transaction verification is expected to fail, asserting that the correct error code (5) is returned by the script. It uses CKB testing utilities and transaction building components.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_11

LANGUAGE: Rust
CODE:
```
];

    // prepare output cell data
    let outputs_data = vec![Bytes::from("carrot"), Bytes::from("tomato")];

    // build transaction
    let tx = TransactionBuilder::default()
        .cell_deps(cell_deps)
        .input(input)
        .outputs(outputs)
        .outputs_data(outputs_data.pack())
        .build();

    let tx = tx.as_advanced_builder().build();

    // run
    let err = context.verify_tx(&tx, MAX_CYCLES).unwrap_err();
    assert_script_error(err, 5);
}
```

----------------------------------------

TITLE: Defining IPC Service Trait with Macro - Rust
DESCRIPTION: Defines a simple service trait using the `#[ckb_script_ipc::service]` procedural macro. This trait serves as the interface for the IPC service, which the macro will use to generate client and server implementations.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/ckb-script-ipc.mdx#_snippet_5

LANGUAGE: rust
CODE:
```
#[ckb_script_ipc::service]
pub trait World {
    fn hello(name: String) -> Result<String, u64>;
}
```

----------------------------------------

TITLE: Create Full-Stack OffCKB Project
DESCRIPTION: Generate a new project from a predefined boilerplate that includes both a script (smart contract) and a frontend application for CKB development.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_14

LANGUAGE: bash
CODE:
```
offckb create <your-project-name, eg:my-first-ckb-project>
```

----------------------------------------

TITLE: Sync Deployed Scripts Configuration with offckb
DESCRIPTION: Executes the `offckb sync-scripts` command in the frontend project's root directory. This command updates the `offckb.config.ts` file with the latest information about the deployed CKB scripts, ensuring the frontend uses the correct script hashes and details.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_18

LANGUAGE: bash
CODE:
```
offckb sync-scripts
```

----------------------------------------

TITLE: Building CKB Transaction for Custom Token (xUDT) Transfer (Part 1) in TypeScript
DESCRIPTION: This snippet shows the initial steps for building a CKB transaction to transfer a custom token. It initializes a signer with the sender's private key, derives the sender's and receiver's lock scripts, constructs the xUDT type script, and creates a transaction object with the receiver's lock script and the specified token amount in the outputs. It then attempts to complete inputs by collecting sender's xUDT cells.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_7

LANGUAGE: typescript
CODE:
```
const signer = new ccc.SignerCkbPrivateKey(cccClient, senderPrivKey);
const senderLockScript = (await signer.getAddressObjSecp256k1()).script;
const receiverLockScript = (
  await ccc.Address.fromString(receiverAddress, cccClient)
).script;

const xudtArgs = udtIssuerArgs;
const xUdtType = await ccc.Script.fromKnownScript(
  cccClient,
  ccc.KnownScript.XUdt,
  xudtArgs
);

const tx = ccc.Transaction.from({
  outputs: [{ lock: receiverLockScript, type: xUdtType }],
  outputsData: [ccc.numLeToBytes(amount, 16)],
});
await tx.completeInputsByUdt(signer, xUdtType);
```

----------------------------------------

TITLE: Sign and Send CKB Transaction (Java)
DESCRIPTION: Demonstrates how to sign a prepared transaction using a private key and then send it to the CKB network using the CKB API. Requires a `TransactionWithScriptGroups` object and a private key. Outputs the transaction hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_7

LANGUAGE: Java
CODE:
```
TransactionWithScriptGroups txWithScriptGroups = ...; // Your built transaction
// 0. Set your private key
String privateKey = "0x6c9ed03816e31...";
// 1. Sign transaction with your private key
TransactionSigner.getInstance(Network.TESTNET).signTransaction(txWithScriptGroups, privateKey);
// 2. Send transaction to CKB node
byte[] txHash = ckbApi.sendTransaction(txWithScriptGroups.txView);
System.out.println(Numeric.toHexString(txHash));
```

----------------------------------------

TITLE: Creating Transaction Using Deployed Script with Lumos (Javascript)
DESCRIPTION: Javascript code using the Lumos SDK to construct a transaction that utilizes the previously deployed CKB script as a type script. Calculates the script's data hash, sets it as the output cell's type script, adds the script cell as a dependency, signs, and sends the transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_3

LANGUAGE: Javascript
CODE:
```
const carrotDataHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
const carrotTypeScript =  {
  codeHash: carrotDataHash,
  hashType: "data",
  args: "0x"
};

let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"100" + "00000000");
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  return outputs;
});
txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0"
  },
  depType: "code"
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const txHash = await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Deploying Duktape to CKB using Lumos (JavaScript)
DESCRIPTION: This JavaScript snippet demonstrates how to deploy the Duktape executable to CKB as a cell using the Lumos library. It reads the Duktape binary from the filesystem, creates a transaction skeleton, adds the binary data to an output cell, signs the transaction, and sends it to the CKB node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_4

LANGUAGE: javascript
CODE:
```
> const fs = require("fs");
> const data = fs.readFileSync("../ckb-duktape/build/duktape");
> data.byteLength
291440
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton, [wallet.address], wallet2.address, "292000" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet.address], 1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const duktapeTxHash = await rpc.sendTransaction(signedTx)
> const duktapeCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
```

----------------------------------------

TITLE: Importing and Using Deployed Smart Contract Info in Frontend (TypeScript)
DESCRIPTION: Demonstrates how to import the configuration generated by `offckb` and construct a `CellDep` object required by CKB Lumos, using the automatically updated deployment details (transaction hash, index, and dependency type) for a specific script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-lock/README.md#_snippet_1

LANGUAGE: ts
CODE:
```
import offckb from 'offckb.config';
import { CellDep } from '@ckb-lumos/lumos';

const lumosConfig = offckb.lumosConfig;
const myContractDep: CellDep = {
  outPoint: {
    txHash: lumosConfig.SCRIPTS.YOUR_SCRIPT_NAME!.TX_HASH,
    index: lumosConfig.SCRIPTS.YOUR_SCRIPT_NAME!.INDEX,
  },
  depType: lumosConfig.SCRIPTS.YOUR_SCRIPT_NAME!.DEP_TYPE,
};
```

----------------------------------------

TITLE: Melt Spore Token using CKB CCC (TypeScript)
DESCRIPTION: This snippet demonstrates how to melt (destroy) a Spore token using the @ckb-ccc/ccc library. It involves specifying the Spore ID, building the melt transaction, completing the transaction fee, sending the transaction, and waiting for confirmation. Requires @ckb-ccc/ccc and @ckb-ccc/playground.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_19

LANGUAGE: TypeScript
CODE:
```
import { ccc } from "@ckb-ccc/ccc";
import { render, signer } from "@ckb-ccc/playground";

function getExplorerTxUrl(txHash: string) {
  const isMainnet = signer.client.addressPrefix === "ckb";
  const baseUrl = isMainnet
    ? "https://explorer.nervos.org"
    : "https://testnet.explorer.nervos.org";

  return `${baseUrl}/transaction/${txHash}`;
}

// Replace with your spore id
const sporeId =
  "0x949c8c2182d6b44c134fe8aaa6e5a7a9701b1bb3bd6d04687ac8575331ca65db";

// Build transaction
const { tx } = await ccc.spore.meltSpore({
  signer,
  id: sporeId,
});
await render(tx);

// Complete missing parts: Pay fee
await tx.completeFeeBy(signer, 1000);
await render(tx);

// Send transaction
const txHash = await signer.sendTransaction(tx);
console.log("Transaction sent:", getExplorerTxUrl(txHash));
await signer.client.waitTransaction(txHash);
// https://testnet.explorer.nervos.org/transaction/0x0362d2ddf2cfe0ffbb3615ab64ae8b6dbd8f60c8c3455dc386c611b1b4bc39de
console.log("Transaction committed:", getExplorerTxUrl(txHash));
await render(tx);
```

----------------------------------------

TITLE: Implementing CKB CCC ConnectWallet Component (TypeScript)
DESCRIPTION: Details the implementation of a React component for connecting a wallet using `@ckb-ccc/connector-react`. It fetches and displays the connected address and balance, and provides buttons for connecting or showing connected info.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_9

LANGUAGE: typescript
CODE:
```
/* eslint-disable*/
import React, { useEffect, useState } from "react";
import { ccc } from "@ckb-ccc/connector-react";
import { truncateAddress } from "../utils/stringUtils";

const ConnectWallet: React.FC = () => {
const { open, wallet } = ccc.useCcc();
const [balance, setBalance] = useState<string>("");
const [address, setAddress] = useState<string>("");
const signer = ccc.useSigner();

    useEffect(() => {
        if (!signer) {
            return;
          }

          (async () => {
            const addr = await signer.getRecommendedAddress();
            setAddress(addr);
          })();

          (async () => {
            const capacity = await signer.getBalance();
            setBalance(ccc.fixedPointToString(capacity));
          })();

        return () => {

        };
    }, [signer]);

    const renderConnectWalletBtn = () => {
        return <div className="cursor-pointer rounded-full border border-solid border-transparent transition-colors flex items-center justify-center bg-foreground text-background gap-2 hover:bg-[#383838] dark:hover:bg-[#ccc] text-sm sm:text-base font-bold h-10 sm:h-12 px-4 sm:px-5"
            onClick={open} >
            Connect Wallet
        </div>
    }

    const renderConnectedWalletInfo = () => {
        return <div className="cursor-pointer rounded-full border border-solid border-transparent transition-colors flex items-center justify-center bg-foreground text-background gap-2 hover:bg-[#383838] dark:hover:bg-[#ccc] text-sm sm:text-base h-10 sm:h-12 px-4 sm:px-5"
        onClick={open} >
            <div className="rounded-full mr-2">
          {wallet && <img src={wallet.icon} alt="avatar" className="w-6 h-6" />}
        </div>
        <div>
          <h2 className="text-sm font-semibold">
            {balance} CKB
          </h2>
          <p className="text-xs flex items-center gap-2">
            {truncateAddress(address, 10, 6)}
          </p>
        </div>
    </div>
    }

    return (
        <div className="flex">
            {wallet ? renderConnectedWalletInfo() : renderConnectWalletBtn()}
        </div>
    );

};

export default ConnectWallet;
```

----------------------------------------

TITLE: Lumos Utility Functions for Omnilock-Metamask (TypeScript)
DESCRIPTION: This TypeScript code defines essential functions for the Omnilock-Metamask example using the Lumos library. It includes type definitions for the Ethereum provider, an asynchronous sleep function, a function to transfer CKB, and a function to check the capacity (balance) of an address. It relies on Lumos for blockchain interactions and assumes integration with a MetaMask-like Ethereum provider for signing.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_9

LANGUAGE: TypeScript
CODE:
```
import {
  BI,
  Cell,
  helpers,
  Indexer,
  RPC,
  config,
  commons,
} from "@ckb-lumos/lumos";
import { blockchain, bytify, hexify } from "@ckb-lumos/lumos/codec";

const CKB_RPC_URL = "https://testnet.ckb.dev/rpc";
const rpc = new RPC(CKB_RPC_URL);
const indexer = new Indexer(CKB_RPC_URL);
// prettier-ignore
interface EthereumRpc {
    (payload: { method: 'personal_sign'; params: [string /*from*/, string /*message*/] }): Promise<string>;
  }

// prettier-ignore
export interface EthereumProvider {
    selectedAddress: string;
    isMetaMask?: boolean;
    enable: () => Promise<string[]>;
    addListener: (event: 'accountsChanged', listener: (addresses: string[]) => void) => void;
    removeEventListener: (event: 'accountsChanged', listener: (addresses: string[]) => void) => void;
    request: EthereumRpc;
  }
// @ts-ignore
export const ethereum = window.ethereum as EthereumProvider;

export function asyncSleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

interface Options {
  from: string;
  to: string;
  amount: string;
}
const SECP_SIGNATURE_PLACEHOLDER = hexify(
  new Uint8Array(
    commons.omnilock.OmnilockWitnessLock.pack({
      signature: new Uint8Array(65).buffer,
    }).byteLength
  )
);

export async function transfer(options: Options): Promise<string> {
  const CONFIG = config.getConfig();
  let tx = helpers.TransactionSkeleton({});
  const fromScript = helpers.parseAddress(options.from);
  const toScript = helpers.parseAddress(options.to);

  // additional 0.001 ckb as tx fee
  // tx fee is calculated by tx size
  // this is just a simple example
  const neededCapacity = BI.from(options.amount).add(100000);
  let collectedSum = BI.from(0);
  const collectedCells: Cell[] = [];
  const collector = indexer.collector({ lock: fromScript, type: "empty" });
  for await (const cell of collector.collect()) {
    collectedSum = collectedSum.add(cell.cellOutput.capacity);
    collectedCells.push(cell);
    if (BI.from(collectedSum).gte(neededCapacity)) break;
  }

  if (collectedSum.lt(neededCapacity)) {
    throw new Error(
      `Not enough CKB, expected: ${neededCapacity}, actual: ${collectedSum} `
    );
  }

  const transferOutput: Cell = {
    cellOutput: {
      capacity: BI.from(options.amount).toHexString(),
      lock: toScript,
    },
    data: "0x",
  };

  const changeOutput: Cell = {
    cellOutput: {
      capacity: collectedSum.sub(neededCapacity).toHexString(),
      lock: fromScript,
    },
    data: "0x",
  };

  tx = tx.update("inputs", (inputs) => inputs.push(...collectedCells));
  tx = tx.update("outputs", (outputs) =>
    outputs.push(transferOutput, changeOutput)
  );
  tx = tx.update("cellDeps", (cellDeps) =>
    cellDeps.push(
      // omni lock dep
      {
        outPoint: {
          txHash: CONFIG.SCRIPTS.OMNILOCK.TX_HASH,
          index: CONFIG.SCRIPTS.OMNILOCK.INDEX,
        },
        depType: CONFIG.SCRIPTS.OMNILOCK.DEP_TYPE,
      },
      // SECP256K1 lock is depended by omni lock
      {
        outPoint: {
          txHash: CONFIG.SCRIPTS.SECP256K1_BLAKE160.TX_HASH,
          index: CONFIG.SCRIPTS.SECP256K1_BLAKE160.INDEX,
        },
        depType: CONFIG.SCRIPTS.SECP256K1_BLAKE160.DEP_TYPE,
      }
    )
  );

  const witness = hexify(
    blockchain.WitnessArgs.pack({ lock: SECP_SIGNATURE_PLACEHOLDER })
  );

  // fill txSkeleton's witness with placeholder
  for (let i = 0; i < tx.inputs.toArray().length; i++) {
    tx = tx.update("witnesses", (witnesses) => witnesses.push(witness));
  }

  tx = commons.omnilock.prepareSigningEntries(tx, { config: CONFIG });

  let signedMessage = await ethereum.request({
    method: "personal_sign",
    params: [ethereum.selectedAddress, tx.signingEntries.get(0).message],
  });

  let v = Number.parseInt(signedMessage.slice(-2), 16);
  if (v >= 27) v -= 27;
  signedMessage =
    "0x" + signedMessage.slice(2, -2) + v.toString(16).padStart(2, "0");

  const signedWitness = hexify(
    blockchain.WitnessArgs.pack({
      lock: commons.omnilock.OmnilockWitnessLock.pack({
        signature: bytify(signedMessage).buffer,
      }),
    })
  );

  tx = tx.update("witnesses", (witnesses) => witnesses.set(0, signedWitness));

  const signedTx = helpers.createTransactionFromSkeleton(tx);
  const txHash = await rpc.sendTransaction(signedTx, "passthrough");

  return txHash;
}

export async function capacityOf(address: string): Promise<BI> {
  const collector = indexer.collector({
    lock: helpers.parseAddress(address),
  });

  let balance = BI.from(0);
  for await (const cell of collector.collect()) {
    balance = balance.add(cell.cellOutput.capacity);
  }

  return balance;
}
```

----------------------------------------

TITLE: Issuing XUDT Transaction with SUS and Unique Type (TypeScript)
DESCRIPTION: Configures and sends a CKB transaction to issue an XUDT. It sets the output data for the token and token info, adds required cell dependencies for the Single Use Lock, XUDT, and Unique Type scripts, completes transaction inputs and fees, sets the Unique Type argument based on the transaction hash, sends the transaction, and waits for it to be committed on the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_12

LANGUAGE: TypeScript
CODE:
```
outputsData: [
  ccc.numLeToBytes(amount, 16),
  tokenInfoToBytes(decimals, symbol, name),
],
});
await mintTx.addCellDepsOfKnownScripts(
  signer.client,
  ccc.KnownScript.SingleUseLock,
  ccc.KnownScript.XUdt,
  ccc.KnownScript.UniqueType
);
await mintTx.completeInputsByCapacity(signer);
if (!mintTx.outputs[1].type) {
  error("Unexpected disappeared output");
  return;
}
mintTx.outputs[1].type!.args = ccc.hexFrom(
  ccc.bytesFrom(ccc.hashTypeId(mintTx.inputs[0], 1)).slice(0, 20)
);
await mintTx.completeFeeBy(signer);
const mintTxHash = await signer.sendTransaction(mintTx);
log("Transaction sent:", explorerTransaction(mintTxHash));
await signer.client.waitTransaction(mintTxHash);
log("Transaction committed:", explorerTransaction(mintTxHash));
```

----------------------------------------

TITLE: Signing and Sending CKB Transaction (Lumos JS)
DESCRIPTION: Demonstrates the final steps of signing a prepared transaction skeleton using Lumos helper functions and sending it to the CKB network via RPC. Requires a `txSkeleton` with signing entries and a `wallet` with a private key. Outputs the transaction hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_11

LANGUAGE: JavaScript
CODE:
```
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const txHash = await rpc.sendTransaction(signedTx)
> txHash
```

----------------------------------------

TITLE: Building CKB Transaction for Custom Token (xUDT) Transfer (Part 2) in TypeScript
DESCRIPTION: This snippet handles the remaining token balance after the transfer. If there's a positive balance difference between inputs and outputs, it adds a change output cell returning the excess tokens and capacity back to the sender's lock script. It then adds necessary cell dependencies, completes inputs for capacity, calculates and adds the transaction fee, and finally sends the signed transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_8

LANGUAGE: typescript
CODE:
```
const balanceDiff =
  (await tx.getInputsUdtBalance(signer.client, xUdtType)) -
  tx.getOutputsUdtBalance(xUdtType);
console.log("balanceDiff: ", balanceDiff);
if (balanceDiff > ccc.Zero) {
  tx.addOutput(
    {
      lock: senderLockScript,
      type: xUdtType,
    },
    ccc.numLeToBytes(balanceDiff, 16)
  );
}
await tx.addCellDepsOfKnownScripts(signer.client, ccc.KnownScript.XUdt);

// Complete missing parts for transaction
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);

const txHash = await signer.sendTransaction(tx);
```

----------------------------------------

TITLE: Initialize Lumos SDK and Wallets (JavaScript)
DESCRIPTION: Sets up the Lumos SDK in a Node.js environment. It requires the `@ckb-lumos/lumos` package, initializes the configuration for the testnet, connects to a testnet RPC and Indexer, and defines two wallet objects with addresses and private keys.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_4

LANGUAGE: js
CODE:
```
$ node
Welcome to Node.js v20.12.0.
Type ".help" for more information.
>
>
> const lumos = require("@ckb-lumos/lumos");
> const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
> const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
> lumos.config.initializeConfig(lumos.config.TESTNET);
> const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6",
};
> const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}
```

----------------------------------------

TITLE: Prepare Transaction for Signing using Lumos
DESCRIPTION: This JavaScript snippet prepares the transaction skeleton for signing. It calculates the transaction fee using `payFeeByFeeRate` and then generates the signing entries required for creating signatures.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_10

LANGUAGE: js
CODE:
```
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
```

----------------------------------------

TITLE: Configuring Lumos SDK for CKB Testnet (JavaScript)
DESCRIPTION: This snippet shows how to initialize the Lumos SDK to connect to the CKB Testnet. It sets up the Indexer and RPC clients using the Testnet RPC URL and initializes the Lumos configuration for the Testnet environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/blockchain-networks.mdx#_snippet_0

LANGUAGE: JavaScript
CODE:
```
const lumos = require("@ckb-lumos/lumos");
const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
lumos.config.initializeConfig(lumos.config.TESTNET);
```

----------------------------------------

TITLE: Signing and Sending CKB Transaction in REPL (sh)
DESCRIPTION: REPL commands using the CCC SDK to complete the transaction inputs and fee, sign the transaction using a private key, and send it to the CKB devnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_16

LANGUAGE: sh
CODE:
```
OffCKB > let signer = new ccc.SignerCkbPrivateKey(client, accounts[0].privkey);
OffCKB > await tx.completeInputsByCapacity(signer);
2
OffCKB > await tx.completeFeeBy(signer, 1000);
[ 0, true ]
OffCKB > await signer.sendTransaction(tx);
'0x1464fec71bd95c4caa2a2640f1573850b25ba9c696c1bfdbe0dc7459717c734b'
OffCKB >
```

----------------------------------------

TITLE: Debugging CKB Script with ckb-debugger and GDB (Bash)
DESCRIPTION: Shows the sequence of commands to start `ckb-debugger` in GDB server mode listening on a specific address/port, and then connect a `riscv64-unknown-elf-gdb` client to that server for interactive debugging of a compiled RISC-V script binary.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_11

LANGUAGE: Bash
CODE:
```
ckb-debugger --mode gdb --gdb-listen 127.0.0.1:9999 --bin fib
riscv64-unknown-elf-gdb fib

(gdb) target remote 127.0.0.1:9999
(gdb) b fib
(gdb) c
```

----------------------------------------

TITLE: Serialize Multiple Bytes in Bytes Fixvec
DESCRIPTION: Illustrates the serialization of a fixed vector containing multiple bytes (0x1234567890abcdef). The serialized form includes the 4-byte length prefix (8) followed by the serialized items.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/encoding-specs.mdx#_snippet_7

LANGUAGE: Hex Bytes
CODE:
```
08 00 00 00, 12 34 56 78 90 ab cd ef
```

----------------------------------------

TITLE: Encode/Decode UTF-8 Message to/from Hex (TypeScript)
DESCRIPTION: Defines two TypeScript functions, `utf8ToHex` and `hexToUtf8`, used to convert a standard UTF-8 string message into its hexadecimal representation for storage in a CKB Cell's data field, and vice-versa for retrieval. It utilizes `TextEncoder` and `TextDecoder`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/write-message.mdx#_snippet_1

LANGUAGE: typescript
CODE:
```
export function utf8ToHex(utf8String: string): string {
  const encoder = new TextEncoder();
  const uint8Array = encoder.encode(utf8String);
  return (
    "0x" +
    Array.prototype.map
      .call(uint8Array, (byte: number) => {
        return ("0" + (byte & 0xff).toString(16)).slice(-2);
      })
      .join("")
  );
}

export function hexToUtf8(hexString: string): string {
  const decoder = new TextDecoder("utf-8");
  const uint8Array = new Uint8Array(
    hexString.match(/[\da-f]{2}/gi)!.map((h) => parseInt(h, 16))
  );
  return decoder.decode(uint8Array);
}
```

----------------------------------------

TITLE: Debug Single Cell Script - OffCKB CLI
DESCRIPTION: This command allows debugging a specific lock or type script within a transaction's input or output cell. Specify the transaction hash and the target script using the format `<cell-type>[<cell-index>].<script-type>`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_24

LANGUAGE: bash
CODE:
```
offckb debug <transaction-hash> --single-script <single-cell-script-option>
```

----------------------------------------

TITLE: Deploying CKB Script to Devnet (Bash)
DESCRIPTION: Deploys the compiled CKB script binary to the local Devnet using the `offckb` tool. The `-t` flag likely indicates a test deployment, and `--network devnet` specifies the target network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/simple-lock.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
cd frontend && offckb deploy -t --network devnet
```

LANGUAGE: text
CODE:
```
contract HASH-LOCK deployed, tx hash: 0x9f55da2b555cdc4412945ff8827b7e77508c84f0b85d82b027d31418e6a9b5d9
wait 4 blocks..
done.
```

----------------------------------------

TITLE: Unlocking HTLC Cell Transaction (JavaScript)
DESCRIPTION: This script demonstrates how to construct a transaction to unlock an HTLC (Hashed Timelock Contract) cell on the CKB network by providing the secret string. It parses command-line arguments for transaction hashes, private key, node URL, secret, and dry run flag. It sets up the CKB connection, loads dependencies, derives the lock hash, loads user cells, and prepares for Molecule serialization of the HTLC witness data, including the secret.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_23

LANGUAGE: JavaScript
CODE:
```
#!/usr/bin/env node

const { Molecule } = require('molecule-javascript')
const crc32 = require('crc32')
const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 8) {
  console.log(`Usage: ${process.argv[1]} <deployed tx hash> <htlc cell tx hash> <private key> <node URL> <secret string> <dry run>`)
  process.exit(1)
}

const deployedTxHash = process.argv[2]
const htlcCellTxHash = process.argv[3]
const privateKey = process.argv[4]
const nodeUrl = process.argv[5]
const secretString = process.argv[6]
const dryrun = process.argv[7] === 'true'

function stringToHexStringArray(s) {
  let a = []
  for (let i = 0; i < s.length; i++) {
    a.push('0x' + ('00' + s.charCodeAt(i).toString(16)).slice(-2))
  }
  return a
}

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const htlcCellCapacity = 200000000000n

  const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
  const htlcWitnessType = new Molecule(
    customSchema.declarations.find(d => d.name == "HtlcWitness"))
  const htlcWitness = htlcWitnessType.serialize([
```

----------------------------------------

TITLE: Generate CKB Transaction JSON for Script Execution - Ruby
DESCRIPTION: This Ruby script generates a CKB transaction JSON file (`tx.json`) for executing a given script binary. It reads the script file, calculates its Blake2b hash, and substitutes placeholders in an embedded transaction template (`DATA`) with the script binary (hex-encoded), its hash, and provided witness arguments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_7

LANGUAGE: Ruby
CODE:
```
#!/usr/bin/env ruby

require "rbnacl"

def bin_to_hex(bin)
  "0x#{bin.unpack1('H*')}"
end

def blake2b(data)
  RbNaCl::Hash::Blake2b.digest(data,
                               personal: "ckb-default-hash",
                               digest_size: 32)
end

if ARGV.length != 2
  STDERR.puts "Usage: runner.rb <script file> <witness args>"
  exit 1
end

script_binary = File.read(ARGV[0])
script_hash = blake2b(script_binary)

tx = DATA.read.sub("@FIB_CODE", bin_to_hex(script_binary))
       .sub("@FIB_HASH", bin_to_hex(script_hash))
       .sub("@FIB_ARG", ARGV[1])

File.write("tx.json", tx)
```

----------------------------------------

TITLE: CKB Script to Check Cell Data (Carrot Forbidden) - C
DESCRIPTION: This CKB script demonstrates how to read cell data using the `ckb_load_cell_data` syscall. It iterates through the output cells of a transaction, reads the first 6 bytes of data from each, and returns -1 (failure) if any cell's data starts with the string "carrot". It requires including `memory.h` and `ckb_syscalls.h`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_2

LANGUAGE: C
CODE:
```
#include <memory.h>
#include "ckb_syscalls.h"

int main(int argc, char* argv[]) {
  int ret;
  size_t index = 0;
  uint64_t len = 0; /* (1) */
  unsigned char buffer[6];

  while (1) {
    len = 6;
    memset(buffer, 0, 6);
    ret = ckb_load_cell_data(buffer, &len, 0, index, CKB_SOURCE_OUTPUT); /* (2) */
    if (ret == CKB_INDEX_OUT_OF_BOUND) {               /* (3) */
      break;
    }

    if (memcmp(buffer, "carrot", 6) == 0) {
      return -1;
    }

    index++;
  }

  return 0;
}
```

----------------------------------------

TITLE: Debugging CKB Script with GDB (GDB)
DESCRIPTION: Shows a typical GDB debugging session interacting with the CKB script. Includes setting a breakpoint, continuing execution, stepping through lines, examining variables (`p cmp`, `p buffer[0]`), and observing the program flow leading to the error.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_8

LANGUAGE: gdb
CODE:
```
(gdb) b main
Breakpoint 1 at 0x106b0: file carrot.c, line 6.
(gdb) c
Continuing.

Breakpoint 1, main (argc=0, argv=0x400000) at carrot.c:6
6         size_t index = 0;
(gdb) n
7         uint64_t len = 0;
(gdb) n
11          len = 6;
(gdb) n
12          memset(buffer, 0, 6);
(gdb) n
13          ret = ckb_load_cell_data(buffer, &len, 0, index, CKB_SOURCE_OUTPUT);
(gdb) n
14          if (ret == CKB_INDEX_OUT_OF_BOUND) {
(gdb) n
18          int cmp = memcmp(buffer, "carrot", 6);
(gdb) n
19          if (cmp) {
(gdb) p cmp
$1 = -99
(gdb) p buffer[0]
$2 = 0 '\\000'
(gdb) n
20            return -1;
```

----------------------------------------

TITLE: Build CKB Transaction (Go)
DESCRIPTION: Provides a detailed example of constructing a `types.Transaction` object including cell dependencies, inputs, outputs, output data, and witnesses, and then organizing the relevant scripts into a `transaction.TransactionWithScriptGroups` for signing.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_6

LANGUAGE: Go
CODE:
```
tx := &types.Transaction{
	Version: 0,
	CellDeps: []*types.CellDep{
		&types.CellDep{
			OutPoint: &types.OutPoint{
				TxHash: types.HexToHash("0xf8de3bb47d055cdf460d93a2a6e1b05f7432f9777c8c474abf4eec1d4aee5d37"),
				Index:  0,
			},
			DepType: types.DepTypeDepGroup,
		},
	},
	HeaderDeps: nil,
	Inputs: []*types.CellInput{
		&types.CellInput{
			Since: 0,
			PreviousOutput: &types.OutPoint{
				TxHash: types.HexToHash("0x2ff7f46d509c85e1878cf091aef0ba0b89f34f9fea9e8bc868aed2d627490512"),
				Index:  1,
			},
		},
	},
	Outputs: []*types.CellOutput{
		&types.CellOutput{
			Capacity: 10000000000,
			Lock: &types.Script{
				CodeHash: types.HexToHash("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"),
				HashType: types.HashTypeType,
				Args:     common.FromHex("0x3f1573b44218d4c12a91919a58a863be415a2bc3")
			},
			Type: nil
		},
		&types.CellOutput{
			Capacity: 90000000000,
			Lock: &types.Script{
				CodeHash: types.HexToHash("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"),
				HashType: types.HashTypeType,
				Args:     common.FromHex("0xb1d41a1fb06f782cf10a87f3e49e80711af63fcf")
			},
			Type: nil
		}
	},
	OutputsData: make([][]byte, 2),
	Witnesses: [][]byte{
		common.FromHex("0x55000000100000005500000055000000410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000")
	}
}

scriptGroups := []*transaction.ScriptGroup{
	&transaction.ScriptGroup{
		Script: types.Script{
			CodeHash: types.HexToHash("0x9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8"),
			HashType: types.HashTypeType,
			Args:     common.FromHex("0x3f1573b44218d4c12a91919a58a863be415a2bc3")
		},
		GroupType:    types.ScriptTypeLock,
		InputIndices: []uint32{0}
	}
}
txWithScriptGroups := &transaction.TransactionWithScriptGroups{
	TxView:       tx,
	ScriptGroups: scriptGroups
}
```

----------------------------------------

TITLE: Call get_tip_block_number RPC via Curl Bash
DESCRIPTION: This command uses curl to send a JSON RPC request to the CKB node's HTTP endpoint (http://localhost:8114) to fetch the latest block number (get_tip_block_number). It pipes a JSON payload containing the RPC method and parameters via echo, removes newlines with tr -d '\n', and sends it as the request body with the correct content type.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/rpcs.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
echo '{
    "id": 2,
    "jsonrpc": "2.0",
    "method": "get_tip_block_number",
    "params": []
}' \
| tr -d '\n' \
| curl -H 'content-type: application/json' -d @- \
http://localhost:8114
```

----------------------------------------

TITLE: Collecting UDT Amounts from Cells (Rust)
DESCRIPTION: These Rust functions collect the total UDT amounts from the relevant input (Source::GroupInput) and output (Source::GroupOutput) cells. They iterate through the cells using QueryIter, load the cell data, parse the UDT amount (assuming a fixed length), handle potential encoding errors, and sum the amounts to return the total.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/sudt-script.mdx#_snippet_7

LANGUAGE: Rust
CODE:
```
fn collect_inputs_amount() -> Result<u128, Error> {
    let mut buf = [0u8; UDT_AMOUNT_LEN];

    let udt_list = QueryIter::new(load_cell_data, Source::GroupInput)
        .map(|data| {
            if data.len() >= UDT_AMOUNT_LEN {
                buf.copy_from_slice(&data);
                Ok(u128::from_le_bytes(buf))
            } else {
                Err(Error::AmountEncoding)
            }
        })
        .collect::<Result<Vec<_>, Error>>()?;
    Ok(udt_list.into_iter().sum::<u128>())
}

fn collect_outputs_amount() -> Result<u128, Error> {
    let mut buf = [0u8; UDT_AMOUNT_LEN];

    let udt_list = QueryIter::new(load_cell_data, Source::GroupOutput)
        .map(|data| {
            if data.len() >= UDT_AMOUNT_LEN {
                buf.copy_from_slice(&data);
                Ok(u128::from_le_bytes(buf))
            } else {
                Err(Error::AmountEncoding)
            }
        })
        .collect::<Result<Vec<_>, Error>>()?;
    Ok(udt_list.into_iter().sum::<u128>())
}
```

----------------------------------------

TITLE: Spore Cell Data Structure
DESCRIPTION: Describes the fundamental structure of a Spore Cell on CKB, detailing the data fields (content-type, content, optional cluster_id), the type script (hash_type, code_hash, args), and the user-defined lock script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-dob.mdx#_snippet_0

LANGUAGE: text
CODE:
```
data:
    content-type: Bytes # String Bytes
    content: Bytes
    # OPTIONAL
    cluster_id: Bytes
type:
    hash_type: "data1"
    code_hash: SPORE_TYPE_DATA_HASH
    args: SPORE_ID
lock:
    <user_defined>
```

----------------------------------------

TITLE: Implementing Parent Script Main Function in Rust
DESCRIPTION: Implements the main function for a parent script that demonstrates using `spawn_cell` to execute a child script, creating a pipe for communication, passing the writable end to the child, reading the output from the readable end, and waiting for the child to exit.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-direct-cross-script-calling.mdx#_snippet_11

LANGUAGE: Rust
CODE:
```
#[no_mangle]
pub unsafe extern "C" fn main() -> u64 {
    let argv = ["Hello", "World!"];
    let fds = pipe();
    let pid = spawn_cell(code_hash, hash_type, &argv, &[fds[1]]);
    let data = read_all(fds[0]);
    assert_eq!(&data, b"Hello World!");
    wait(pid);
    return 0;
}
```

----------------------------------------

TITLE: Defining Role and Character Tables Molecule C
DESCRIPTION: Defines the `Class` type for character classes and the main character types, `Hero` and `Monster`, using Molecule's `table` type. The `Hero` table includes fields for class, level, experience, stats (hp, mp, base_damage), attributes (`Attributes`), and skills (`Skills`), importing necessary types.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/example-role-playing-game.mdx#_snippet_2

LANGUAGE: c
CODE:
```
import attributes;
import skills;
import common/basic_types;

// We have only 3 classes: Fighter, Ranger and Mage. A `byte` is enough.
array Class [byte; 1];

table Hero {
    class: Class,
    level: Uint8,
    experiences: Uint32,
    hp: Uint16,
    mp: Uint16,
    base_damage: Uint16,
    attrs: Attributes,
    skills: Skills,
}

table Monster {
    hp: Uint16,
    damage: Uint16,
}
```

----------------------------------------

TITLE: Defining a Struct with a Single Byte Field (Molecule Schema)
DESCRIPTION: Defines a fixed-size struct type named `OnlyAByte` with a single field `f1` of type `byte`. Structs with fixed-size fields are also fixed-size. The example shows a byte value `ab` serialized directly as `ab`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/encoding-specs.mdx#_snippet_3

LANGUAGE: Molecule Schema
CODE:
```
struct OnlyAByte { f1: byte }
```

----------------------------------------

TITLE: Signing and Sending CKB Transaction (Go)
DESCRIPTION: Demonstrates how to sign a prepared CKB transaction using a private key and then send it to a CKB node. Requires a TransactionWithScriptGroups object and a private key string. Uses ckbClient to send the transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_7

LANGUAGE: Go
CODE:
```
// Your built txWithScriptGroups
var txWithScriptGroups *transaction.TransactionWithScriptGroups
// 0. Set your private key
privKey := "0xccb083b37aa346c5ce2e1f99a687a153baa04052f26db6ab3c26d6a4cc15c5f1"
// 1. Sign transaction with your private key
txSigner := signer.GetTransactionSignerInstance(types.NetworkTest)
txSigner.SignTransactionByPrivateKeys(txWithScriptGroups, privKey)
// 2. Send transaction to CKB node
txHash, err := ckbClient.SendTransaction(context.Background(), txWithScriptGroups.TxView)
```

----------------------------------------

TITLE: Start of Issue Token Function - TypeScript
DESCRIPTION: Begins the `issueToken` function, which takes the issuer's private key and token amount. It initializes a CKB signer, retrieves the issuer's lock script, and constructs the arguments for the xUDT script by hashing the lock script (serving as the unique token ID) and appending a placeholder ('00000000'). It then prepares to create the xUDT type script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_1

LANGUAGE: ts
CODE:
```
export async function issueToken(privKey: string, amount: string) {
  const signer = new ccc.SignerCkbPrivateKey(cccClient, privKey);
  const lockScript = (await signer.getAddressObjSecp256k1()).script;
  const xudtArgs = lockScript.hash() + "00000000";

  const typeScript = await ccc.Script.fromKnownScript(
    signer.client,
    ccc.KnownScript.XUdt,
    xudtArgs
  );
  ...
}
```

----------------------------------------

TITLE: Finalizing & Sending CKB Transaction (Lumos JS)
DESCRIPTION: This snippet demonstrates the final steps of preparing a CKB transaction using Lumos. It pays the fee, prepares signing entries, signs the transaction using a private key, seals the transaction, and sends it to the CKB RPC node. Requires a txSkeleton object, a wallet address, a fee rate, a private key, and an RPC client.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_13

LANGUAGE: JavaScript
CODE:
```
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const txHash = await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Using CKB CCC ConnectWallet Component (TSX)
DESCRIPTION: Demonstrates how to integrate the `ConnectWallet` component into a React application by simply rendering it within a functional component.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_10

LANGUAGE: tsx
CODE:
```
import React from "react";
import ConnectWallet from "@/src/components/ConnectWallet";

function App() {
  return <ConnectWallet />;
}
```

----------------------------------------

TITLE: Starting CKB Debugger with Transaction File (Bash)
DESCRIPTION: This bash command launches the `ckb-debugger` tool, specifying the transaction file generated by the dumper ("duktape.json"). It also configures the debugger to focus on a specific cell (index 0) within the transaction's output cells and targets the 'type' script group.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_17

LANGUAGE: Bash
CODE:
```
$ ckb-debugger  --tx-file duktape.json --cell-index 0 --cell-type output --script-group-type type
```

----------------------------------------

TITLE: Create Transaction to Deploy Script Data (JavaScript)
DESCRIPTION: Demonstrates creating a transaction skeleton using Lumos to deploy a compiled script (`carrot`) as the data part of a new cell. It reads the script file, transfers capacity to a recipient address, updates the output cell's data with the script's hexadecimal representation, pays the fee, prepares signing entries, signs the transaction, and sends it to the CKB network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_5

LANGUAGE: js
CODE:
```
> const fs = require("fs");
> const data = fs.readFileSync("carrot");
> data.byteLength
7744
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address], wallet2.address, "8000" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address], 1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const carrotTxHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Set Script Type on Output Cell using Lumos
DESCRIPTION: This JavaScript snippet demonstrates how to create a new transaction that utilizes the deployed script. It starts with a new transaction skeleton, transfers capacity to an output cell, and then updates that output cell's `type` field to the previously created `carrotTypeScript` object. This indicates that the script should be executed when this cell is consumed.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_8

LANGUAGE: js
CODE:
```
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address], wallet2.address,"100" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  return outputs;
});
```

----------------------------------------

TITLE: NervosDAO Management Component and Helpers (TSX)
DESCRIPTION: This snippet contains React component logic and helper functions for managing NervosDAO operations. It includes functions to parse epoch data, calculate potential profit from a DAO cell, determine the earliest claimable epoch, and a React component (`DaoButton`) to handle the UI and logic for interacting with a specific DAO cell, including fetching transaction and header information.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_20

LANGUAGE: tsx
CODE:
```
"use client";

import React, { useEffect, useMemo, useState } from "react";
import { TextInput } from "@/src/components/Input";
import { Button } from "@/src/components/Button";
import { ccc } from "@ckb-ccc/connector-react";
import { useGetExplorerLink } from "@/src/utils";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";
import { BigButton } from "@/src/components/BigButton";

function parseEpoch(epoch: ccc.Epoch): ccc.FixedPoint {
  return (
    ccc.fixedPointFrom(epoch[0].toString()) +
    (ccc.fixedPointFrom(epoch[1].toString()) * ccc.fixedPointFrom(1)) /
      ccc.fixedPointFrom(epoch[2].toString())
  );
}

function getProfit(
  dao: ccc.Cell,
  depositHeader: ccc.ClientBlockHeader,
  withdrawHeader: ccc.ClientBlockHeader
): ccc.Num {
  const occupiedSize = ccc.fixedPointFrom(
    dao.cellOutput.occupiedSize + ccc.bytesFrom(dao.outputData).length
  );
  const profitableSize = dao.cellOutput.capacity - occupiedSize;

  return (
    (profitableSize * withdrawHeader.dao.ar) / depositHeader.dao.ar -
    profitableSize
  );
}

function getClaimEpoch(
  depositHeader: ccc.ClientBlockHeader,
  withdrawHeader: ccc.ClientBlockHeader
): ccc.Epoch {
  const depositEpoch = depositHeader.epoch;
  const withdrawEpoch = withdrawHeader.epoch;
  const intDiff = withdrawEpoch[0] - depositEpoch[0];
  // deposit[1]    withdraw[1]
  // ---------- <= -----------
  // deposit[2]    withdraw[2]
  if (
    intDiff % ccc.numFrom(180) !== ccc.numFrom(0) ||
    depositEpoch[1] * withdrawEpoch[2] <= depositEpoch[2] * withdrawEpoch[1]
  ) {
    return [
      depositEpoch[0] +
        (intDiff / ccc.numFrom(180) + ccc.numFrom(1)) * ccc.numFrom(180),
      depositEpoch[1],
      depositEpoch[2],
    ];
  }

  return [
    depositEpoch[0] + (intDiff / ccc.numFrom(180)) * ccc.numFrom(180),
    depositEpoch[1],
    depositEpoch[2],
  ];
}

function DaoButton({ dao }: { dao: ccc.Cell }) {
  const { signer, createSender } = useApp();
  const { log, error } = createSender("Transfer");

  const { explorerTransaction } = useGetExplorerLink();

  const [tip, setTip] = useState<ccc.ClientBlockHeader | undefined>();
  const [infos, setInfos] = useState<
    |
        [
          ccc.Num,
          ccc.ClientTransactionResponse,
          ccc.ClientBlockHeader,
          [undefined | ccc.ClientTransactionResponse, ccc.ClientBlockHeader]
        ]
      |
        undefined
  >();

  const isNew = useMemo(() => dao.outputData === "0x0000000000000000", [dao]);
  useEffect(() => {
    if (!signer) {
      return;
    }

    (async () => {
      const tipHeader = await signer.client.getTipHeader();
      setTip(tipHeader);

      const previousTxRes = await signer.client.getTransactionWithHeader(
        dao.outPoint.txHash
      );
      if (!previousTxRes || !previousTxRes.header) {
        return;
      }
      const { transaction: previousTx, header: previousHeader } = previousTxRes;

      const claimInfo = await (async (): Promise<typeof infos> => {
        if (isNew) {
          return;
        }

        const depositTxHash =
          previousTx.transaction.inputs[Number(dao.outPoint.index)]
            .previousOutput.txHash;
        const depositTxRes = await signer.client.getTransactionWithHeader(
          depositTxHash
        );
        if (!depositTxRes || !depositTxRes.header) {
          return;
        }
        const { transaction: depositTx, header: depositHeader } = depositTxRes;

        return [
          getProfit(dao, depositHeader, previousHeader),
          depositTx,
          depositHeader,
          [previousTx, previousHeader],
        ];
      })();

      if (claimInfo) {
        setInfos(claimInfo);
      } else {
        setInfos([
          getProfit(dao, previousHeader, tipHeader),
          previousTx,
          previousHeader,
          [undefined, tipHeader],
        ]);
      }
    })();
  }, [dao, signer, isNew]);

  return (
    <BigButton
      key={ccc.hexFrom(dao.outPoint.toBytes())}
      size="sm"
      iconName="Vault"
      onClick={() => {
        if (!signer || !infos) {
          return;
        }

        (async () => {
          const [profit, depositTx, depositHeader] = infos;
          if (!depositTx.blockHash || !depositTx.blockNumber) {
            error(
              "Unexpected empty block info for",
              explorerTransaction(dao.outPoint.txHash)
            );
            return;
          }
          const { blockHash, blockNumber } = depositTx;

          let tx;
          if (isNew) {
            tx = ccc.Transaction.from({
              headerDeps: [blockHash],
              inputs: [{ previousOutput: dao.outPoint }],
              outputs: [dao.cellOutput],
              outputsData: [ccc.numLeToBytes(blockNumber, 8)],
            });

            await tx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.NervosDao
            );

```

----------------------------------------

TITLE: Initialize RPC Client - Lumos - TypeScript
DESCRIPTION: Imports the `RPC` class from Lumos and demonstrates how to create an RPC client instance. It shows example URLs for connecting to Testnet, Devnet, and Mainnet, and connects to the Testnet URL to interact with a CKB node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_4

LANGUAGE: TypeScript
CODE:
```
import { RPC } from "@ckb-lumos/lumos";

const TESTNET_RPC_URL = "https://testnet.ckb.dev"; // Testnet
const DEVNET_RPC_URL = "http://127.0.0.1:8114"; // Devnet
const MAINNET_RPC_URL = "https://mainnet.ckb.dev/rpc"; // Mainnet

// Connect to Testnet
const rpc = new RPC(TESTNET_RPC_URL);
```

----------------------------------------

TITLE: Creating a New dApp Project with OffCKB (Bash)
DESCRIPTION: Initializes a new full-stack dApp project using the offCKB CLI. Replace <my-dapp-project> with the desired project name. The command will prompt you to select a frontend framework.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_1

LANGUAGE: bash
CODE:
```
offckb create <my-dapp-project>
```

----------------------------------------

TITLE: Testing sUDT Transfer Transaction in Rust
DESCRIPTION: This Rust test function, `test_transfer_sudt`, simulates a UDT transfer. It sets up the necessary CKB environment including lock and type scripts, creates input and output cells with specified token amounts, builds a transaction, and verifies its execution using the sUDT script. It checks if the transaction passes verification.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/sudt-script.mdx#_snippet_8

LANGUAGE: Rust
CODE:
```
#[test]
fn test_transfer_sudt() {
    let mut context = Context::default();

    // build lock script
    let always_success_out_point = context.deploy_cell(ALWAYS_SUCCESS.clone());
    let lock_script = context
        .build_script(&always_success_out_point, Default::default())
        .expect("script");
    let lock_script_dep = CellDep::new_builder()
        .out_point(always_success_out_point)
        .build();

    // prepare scripts
    let contract_bin: Bytes = Loader::default().load_binary("sudt");
    let out_point = context.deploy_cell(contract_bin);
    let type_script = context
        .build_script(&out_point, Bytes::from(vec![42]))
        .expect("script");
    let type_script_dep = CellDep::new_builder().out_point(out_point).build();

    let input_token: u128 = 400;
    let output_token1: u128 = 300;
    let output_token2: u128 = 100;

    // prepare cells
    let input_out_point = context.create_cell(
        CellOutput::new_builder()
            .capacity(1000u64.pack())
            .lock(lock_script.clone())
            .type_(Some(type_script.clone()).pack())
            .build(),
        input_token.to_le_bytes().to_vec().into(),
    );
    let input = CellInput::new_builder()
        .previous_output(input_out_point)
        .build();
    let outputs = vec![
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script.clone())
            .type_(Some(type_script.clone()).pack())
            .build(),
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script)
            .type_(Some(type_script).pack())
            .build(),
    ];

    let outputs_data = vec![
        Bytes::from(output_token1.to_le_bytes().to_vec()),
        Bytes::from(output_token2.to_le_bytes().to_vec()),
    ];

    // build transaction
    let tx = TransactionBuilder::default()
        .input(input)
        .outputs(outputs)
        .outputs_data(outputs_data.pack())
        .cell_dep(lock_script_dep)
        .cell_dep(type_script_dep)
        .build();
    let tx = context.complete_tx(tx);

    // run
    let cycles = context
        .verify_tx(&tx, 10_000_000)
        .expect("pass verification");
    println!("consume cycles: {}", cycles);
}
```

----------------------------------------

TITLE: Build and Send CKB Transaction with Failing Type Script
DESCRIPTION: This snippet constructs a transaction that includes an output cell with data containing 'carrot' and a type script designed to reject such data. It adds necessary cell dependencies, pays fees, prepares signing entries, signs, and sends the transaction, demonstrating a script validation failure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_12

LANGUAGE: JavaScript
CODE:
```
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"400" + "00000000");
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  cell.data = "0x" + Buffer.from("carrot123", "utf8").toString("hex");
  return outputs;
});
txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: carrotTxHash,
    index: "0x0",
  },
  depType: "code",
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Compile CKB C Script with Debug Info
DESCRIPTION: This Bash script demonstrates the steps to compile the `carrot.c` CKB script using the official RISC-V GNU toolchain within a Docker container. The `-g` flag is included in the `gcc` command to generate debugging information, which is essential for GDB debugging. It also shows copying necessary CKB header files.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_1

LANGUAGE: Bash
CODE:
```
$ ls
carrot.c
$ git clone https://github.com/nervosnetwork/ckb-system-scripts
$ cp ckb-system-scripts/c/ckb_*.h ./
$ ls
carrot.c  ckb_consts.h  ckb_syscalls.h  ckb-system-scripts/
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20191012 bash
root@3efa454be9af:/# cd /code
root@3efa454be9af:/code# riscv64-unknown-elf-gcc carrot.c -g -o carrot
root@3efa454be9af:/code# exit
```

----------------------------------------

TITLE: Running CKB Standalone Debugger in GDB Mode (Bash)
DESCRIPTION: Installs the `ckb-standalone-debugger` via `cargo` and then runs it in GDB mode, listening on port 2000. It uses the `carrot.json` file, targeting the output cell at index 0, and debugging the type script group.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_6

LANGUAGE: bash
CODE:
```
$ cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger
$ ckb-debugger --mode gdb --gdb-listen 0.0.0.0:2000 --tx-file carrot.json --cell-index 0 --cell-type output --script-group-type type
```

----------------------------------------

TITLE: Install Clang Compiler (≥v18)
DESCRIPTION: Install the Clang compiler, essential for building CKB Scripts. Version ≥18 is required for compatibility with CKB tools. Instructions cover MacOS, Linux (Debian/Ubuntu, Fedora, Arch), and Windows.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_15

LANGUAGE: bash
CODE:
```
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
brew install llvm@18
```

LANGUAGE: bash
CODE:
```
wget https://apt.llvm.org/llvm.sh && chmod +x llvm.sh && sudo ./llvm.sh 18 && rm llvm.sh  # Debian/Ubuntu
sudo dnf -y install clang  # Fedora
sudo pacman --noconfirm -Syu clang  # ArchLinux
```

LANGUAGE: bash
CODE:
```
Set-ExecutionPolicy RemoteSigned -Scope CurrentUser
iwr -useb get.scoop.sh | iex
scoop install llvm yasm
```

----------------------------------------

TITLE: Compile CKB Script with Docker RISC-V Toolchain
DESCRIPTION: This bash script demonstrates how to compile a CKB script written in C (`carrot.c`) using a pre-built Docker image containing the RISC-V GNU toolchain. It mounts the current directory into the container, navigates to it, compiles the code using `riscv64-unknown-elf-gcc`, and then exits the container.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_3

LANGUAGE: bash
CODE:
```
$ ls
carrot.c  ckb_consts.h  ckb_syscalls.h
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:xenial bash
root@dc2c0c209dcd:/# cd /code
root@dc2c0c209dcd:/code# riscv64-unknown-elf-gcc -Os carrot.c -o carrot
root@dc2c0c209dcd:/code# exit
exit
$ ls
carrot*  carrot.c  ckb_consts.h  ckb_syscalls.h
```

----------------------------------------

TITLE: Loading Cell Data Fields via CKB Syscall in Debugger (Duktape)
DESCRIPTION: This snippet demonstrates using CKB syscalls in the Duktape debugger to access specific fields of cells within the transaction. It shows how to get constants like `CKB.SOURCE.OUTPUT` and `CKB.CELL.CAPACITY` and how to use `CKB.load_cell_by_field` to retrieve the capacity of a cell, converting the result to hex.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_20

LANGUAGE: Bash
CODE:
```
duk> print(CKB.SOURCE.OUTPUT)
2
= undefined
duk> print(CKB.CELL.CAPACITY)
0
= undefined
duk> capacity_field = CKB.load_cell_by_field(0, 0, CKB.SOURCE.OUTPUT, CKB.CELL.CAPACITY)
= [object ArrayBuffer]
duk> buf2hex(capacity_field)
= 00e40b5402000000
```

----------------------------------------

TITLE: CKB JavaScript UDT Script Logic
DESCRIPTION: The core JavaScript code for the User Defined Token (UDT) script intended to run on the CKB VM via Duktape. It validates arguments, sums token amounts from input and output cells, and enforces rules for token transfer and initial creation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_3

LANGUAGE: javascript
CODE:
```
if (CKB.ARGV.length !== 1) {
  throw "Requires only one argument!";
}

var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var ret = CKB.CODE.INDEX_OUT_OF_BOUND;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, input_index, CKB.SOURCE.GROUP_INPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid input cell!";
  }
  var view = new DataView(buffer);
  input_coins += view.getUint32(0, true);
  input_index += 1;
}

var output_index = 0;
var output_coins = 0;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, output_index, CKB.SOURCE.GROUP_OUTPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid output cell!";
  }
  var view = new DataView(buffer);
  output_coins += view.getUint32(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  if (!((input_index === 0) && (output_index === 1))) {
    throw "Invalid token issuing mode!";
  }
  var first_input = CKB.load_input(0, 0, CKB.SOURCE.INPUT);
  if (typeof first_input === "number") {
    throw "Cannot fetch the first input";
  }
  var hex_input_outpoint = Array.prototype.map
    .call(new Uint8Array(first_input), function (x) {
      return ("00" + x.toString(16)).slice(-2);
    })
    .join("")
    .slice(16); // remove the first 8 bytes of since
  var outpoint_arg = new TextDecoder().decode(CKB.ARGV[0]);
  if (outpoint_arg != hex_input_outpoint) {
    throw "Invalid creation argument!";
  }
}
```

----------------------------------------

TITLE: Asserting CKB Script Error Code in Rust Tests
DESCRIPTION: This Rust helper function is designed for unit tests to verify that a CKB script execution error matches an expected error code. It takes the `Error` object returned by the CKB VM and the anticipated error code, converting the error to a string to check for the presence of the formatted error code message.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_12

LANGUAGE: Rust
CODE:
```
fn assert_script_error(err: Error, err_code: i8) {
    let error_string = err.to_string();
    assert!(
        error_string.contains(format!("error code {} ", err_code).as_str()),
        "error_string: {}, expected_error_code: {}",
        error_string,
        err_code
    );
}
```

----------------------------------------

TITLE: Creating New Project with npx (Bash)
DESCRIPTION: Uses the `create-ccc-app` CLI tool via npx to quickly scaffold a new project with built-in CCC wallet connection support. Using `@latest` ensures the most recent version is used.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_5

LANGUAGE: Bash
CODE:
```
npx create-ccc-app@latest
```

----------------------------------------

TITLE: Storing DNA in Spore Cell Content (JavaScript)
DESCRIPTION: Illustrates the structure of the content field in a Spore Cell when using the DOB/0 protocol, showing how the contentType is set and how the dna can be stored as an object, raw hex string, or array.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/spore-dob-0.mdx#_snippet_1

LANGUAGE: JavaScript
CODE:
```
{
    contentType: "dob/0",
    content: {
        dna: "0xefc2866a311da5b6dfcdfc4e3c22d00d024a53217ebc33855eeab1068990ed9d"
    },
    // or content: "0xefc2866a311da5b6dfcdfc4e3c22d00d024a53217ebc33855eeab1068990ed9d",
    // or content: ["0xefc2866a311da5b6dfcdfc4e3c22d00d024a53217ebc33855eeab1068990ed9d"]
    content_id: "0x3b0e340b6c77d7b6e4f1fb2946d526ba65bfd196a27d9a7e5b6f06b82af5d07e"
}
```

----------------------------------------

TITLE: Loading and Parsing CKB Script and Args (JavaScript)
DESCRIPTION: Loads the current CKB script using the CKB syscall `CKB.load_script(0)`, converts the raw bytes to a hex string, deserializes the script structure using the Molecule 'Script' type, and extracts the arguments field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_13

LANGUAGE: javascript
CODE:
```
const current_script = scriptType.deserialize(bytesToHex(CKB.load_script(0)))
const args = hexStringArrayToHexString(current_script[2][1])
const htlcArgs = htlcArgsType.deserialize(args)
```

----------------------------------------

TITLE: Generating CKB Address from Private Key (Rust)
DESCRIPTION: Provides a Rust example for generating a new CKB address. It shows how to generate a random private key, derive the public key using secp256k1, create an address payload, and construct the final CKB address for a specified network type.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/rust.mdx#_snippet_8

LANGUAGE: Rust
CODE:
```
use ckb_sdk::types::{Address, AddressPayload, NetworkType};
use rand::Rng;

let mut rng = rand::thread_rng();
let privkey_bytes: [u8; 32] = rng.gen();
let secp_secret_key = secp256k1::SecretKey::from_slice(&privkey_bytes).unwrap();
let pubkey =
    secp256k1::PublicKey::from_secret_key(&ckb_crypto::secp::SECP256K1, &secp_secret_key);
let payload = AddressPayload::from_pubkey(&pubkey);
let address = Address::new(NetworkType::Mainnet, payload, true);
println!("address: {}", address.to_string());
```

----------------------------------------

TITLE: Dumping CKB Transaction Skeleton to JSON (JavaScript)
DESCRIPTION: Formats a Lumos transaction skeleton into a raw transaction JSON object and writes it to a local file named 'failed-tx.json' using Node.js file system module.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_4

LANGUAGE: JavaScript
CODE:
```
let txJson = rpc.paramsFormatter.toRawTransaction(lumos.helpers.createTransactionFromSkeleton(txSkeleton))
fs.writeFileSync('failed-tx.json', JSON.stringify(txJson, null, 2))
```

----------------------------------------

TITLE: Querying Issued Custom Token Cells (xUDT) in TypeScript
DESCRIPTION: This function queries live cells on the CKB network that represent a specific custom token (xUDT). It constructs a Type Script using the provided "xudtArgs" (which acts as the token's unique ID) and uses a client to find all cells matching this type script. The function returns an array of these cells.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_5

LANGUAGE: typescript
CODE:
```
export async function queryIssuedTokenCells(xudtArgs: HexString) {
  const typeScript = await ccc.Script.fromKnownScript(
    cccClient,
    ccc.KnownScript.XUdt,
    xudtArgs
  );

  const collected: ccc.Cell[] = [];
  const collector = cccClient.findCellsByType(typeScript, true);
  for await (const cell of collector) {
    collected.push(cell);
  }
  return collected;
}
```

----------------------------------------

TITLE: Install Dependencies and Start DApp (Bash)
DESCRIPTION: Installs project dependencies using npm and then starts the development server for the dApp. This command is run from the 'frontend' directory.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_10

LANGUAGE: bash
CODE:
```
npm i && npm run dev
```

----------------------------------------

TITLE: Test CKB Script Without Forbidden Data (Rust)
DESCRIPTION: This Rust test function `test_no_carrot` simulates a CKB transaction to verify a script that forbids data starting with "carrot". It deploys the script and an always-success lock script, constructs a transaction with inputs and outputs, and sets output data that does *not* start with "carrot". The test then verifies the transaction using `ckb_testtool`, expecting it to pass, demonstrating the script correctly allows transactions without the forbidden data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_9

LANGUAGE: Rust
CODE:
```
// Include your tests here
// See https://github.com/xxuejie/ckb-native-build-sample/blob/main/tests/src/tests.rs for examples

use super::*;
use ckb_testtool::{
    builtin::ALWAYS_SUCCESS,
    ckb_types::{bytes::Bytes, core::TransactionBuilder, packed::*, prelude::*},
    context::Context,
};

const MAX_CYCLES: u64 = 10_000_000;

#[test]
fn test_no_carrot() {
    // deploy contract
    let mut context = Context::default();
    let loader = Loader::default();
    let carrot_bin = loader.load_binary("carrot");
    let carrot_out_point = context.deploy_cell(carrot_bin);
    let carrot_cell_dep = CellDep::new_builder()
        .out_point(carrot_out_point.clone())
        .build();

    // prepare scripts
    let always_success_out_point = context.deploy_cell(ALWAYS_SUCCESS.clone());
    let lock_script = context
        .build_script(&always_success_out_point.clone(), Default::default())
        .expect("script");
    let lock_script_dep = CellDep::new_builder()
        .out_point(always_success_out_point)
        .build();

    // prepare cell deps
    let cell_deps: Vec<CellDep> = vec![lock_script_dep, carrot_cell_dep];

    // prepare cells
    let input_out_point = context.create_cell(
        CellOutput::new_builder()
            .capacity(1000u64.pack())
            .lock(lock_script.clone())
            .build(),
        Bytes::new(),
    );
    let input = CellInput::new_builder()
        .previous_output(input_out_point.clone())
        .build();

    let type_script = context
        .build_script(&carrot_out_point, Bytes::new())
        .expect("script");

    let outputs = vec![
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script.clone())
            .type_(Some(type_script.clone()).pack())
            .build(),
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script)
            .build(),
    ];

    // prepare output cell data
    let outputs_data = vec![Bytes::from("apple"), Bytes::from("tomato")];

    // build transaction
    let tx = TransactionBuilder::default()
        .cell_deps(cell_deps)
        .input(input)
        .outputs(outputs)
        .outputs_data(outputs_data.pack())
        .build();

    let tx = tx.as_advanced_builder().build();

    // run
    let cycles = context
        .verify_tx(&tx, MAX_CYCLES)
        .expect("pass verification");
    println!("consume cycles: {}", cycles);
}
```

----------------------------------------

TITLE: Test CKB Script With Forbidden Data (Rust)
DESCRIPTION: This Rust test function `test_carrot_attack` simulates a CKB transaction to verify a script that forbids data starting with "carrot". It deploys the script and an always-success lock script, constructs a transaction with inputs and outputs. The intention is to set output data that *does* start with "carrot" to test the script's rejection logic, although the provided snippet is incomplete and cuts off before the output data is fully defined and the verification is called.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_10

LANGUAGE: Rust
CODE:
```
#[test]
fn test_carrot_attack() {
    // deploy contract
    let mut context = Context::default();
    let loader = Loader::default();
    let carrot_bin = loader.load_binary("carrot");
    let carrot_out_point = context.deploy_cell(carrot_bin);
    let carrot_cell_dep = CellDep::new_builder()
        .out_point(carrot_out_point.clone())
        .build();

    // prepare scripts
    let always_success_out_point = context.deploy_cell(ALWAYS_SUCCESS.clone());
    let lock_script = context
        .build_script(&always_success_out_point.clone(), Default::default())
        .expect("script");
    let lock_script_dep = CellDep::new_builder()
        .out_point(always_success_out_point)
        .build();

    // prepare cell deps
    let cell_deps: Vec<CellDep> = vec![lock_script_dep, carrot_cell_dep];

    // prepare cells
    let input_out_point = context.create_cell(
        CellOutput::new_builder()
            .capacity(1000u64.pack())
            .lock(lock_script.clone())
            .build(),
        Bytes::new(),
    );
    let input = CellInput::new_builder()
        .previous_output(input_out_point.clone())
        .build();

    let type_script = context
        .build_script(&carrot_out_point, Bytes::new())
        .expect("script");

    let outputs = vec![
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script.clone())
            .type_(Some(type_script.clone()).pack())
            .build(),
        CellOutput::new_builder()
            .capacity(500u64.pack())
            .lock(lock_script)
            .build(),

```

----------------------------------------

TITLE: Define Simple JavaScript Script (JavaScript)
DESCRIPTION: Provides the content for the 'hello.js' file. This is a basic JavaScript script that prints a greeting message to the console when executed by the ckb-js-vm.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_8

LANGUAGE: JavaScript
CODE:
```
console.log("hello, ckb-js-script!");
```

----------------------------------------

TITLE: Initialize Transaction with Output Data (TypeScript)
DESCRIPTION: Shows the initial steps within the `buildMessageTx` function to create a new CKB transaction using the CCC library. It encodes the message to hex and sets it as the data for the output Cell, defining where the message will be stored on-chain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/write-message.mdx#_snippet_2

LANGUAGE: typescript
CODE:
```
const onChainMemoHex = utf8ToHex(onChainMemo);
const tx = ccc.Transaction.from({
  outputs: [{ lock: signerAddress.script }],
  outputsData: [onChainMemoHex]
});
```

----------------------------------------

TITLE: Defining xUDT Cell Structure - CKB Structure
DESCRIPTION: Describes the data, type, and lock fields of an xUDT cell on CKB. It shows how the amount and xUDT-specific data are stored in the data field, and how the type script uses code_hash and args (including the owner lock hash and xUDT args) to define the token type.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/xudt.mdx#_snippet_0

LANGUAGE: CKB Structure
CODE:
```
data:
  <amount: uint128> <xUDT data>
type:
  code_hash: xUDT type script
  args: <owner lock script hash> <xUDt args>
lock: <user_defined>
```

----------------------------------------

TITLE: Defining Extension Script Structure - Molecule
DESCRIPTION: Defines the Molecule schema for an extension script (`Script`) and a vector of extension scripts (`ScriptVec`). Each `Script` entry includes the code hash, hash type, and arguments for a specific extension behavior.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/xudt.mdx#_snippet_2

LANGUAGE: Molecule
CODE:
```
table Script {
    code_hash:      Byte32,
    hash_type:      byte,
    args:           Bytes,
}

vector ScriptVec <Script>
```

----------------------------------------

TITLE: Build and Send CKB Transaction with OffCKB REPL (javascript)
DESCRIPTION: Demonstrates building a CKB transaction in the `OffCKB` REPL environment. It constructs the script args, creates the `type` script, defines the transaction structure with outputs and cell dependencies, completes inputs and fee, signs, and sends the transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_20

LANGUAGE: javascript
CODE:
```
let baseScriptArgs = `0x0000${myScripts['fib.bc'].codeHash.slice(2)}0${ccc.hashTypeToBytes(myScripts['fib.bc'].hashType).toString()}`;
let baseScript = ccc.Script.from({
  codeHash: myScripts["ckb-js-vm"].codeHash,
  hashType: myScripts["ckb-js-vm"].hashType,
  args: baseScriptArgs,
})
let tx = ccc.Transaction.from({
  outputs: [
    {
      lock: accounts[0].lockScript,
      type: baseScript
    },
  ],
 cellDeps: [
  ...myScripts["ckb-js-vm"].cellDeps.map(c => c.cellDep),
  ...myScripts['fib.bc'].cellDeps.map(c => c.cellDep)
  ],
});
let signer = new ccc.SignerCkbPrivateKey(client, accounts[0].privkey);
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);
await signer.sendTransaction(tx);
```

----------------------------------------

TITLE: Molecule Definition of Script Structure
DESCRIPTION: Provides the definition of the Script structure using Molecule serialization syntax. It specifies the fields required for a script: `code_hash`, `hash_type`, and `args`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-calculate-script-hash.mdx#_snippet_1

LANGUAGE: Molecule Definition
CODE:
```
table Script {
    code_hash:      Byte32,
    hash_type:      byte,
    args:           Bytes,
}
```

----------------------------------------

TITLE: Debug CKB Transaction (Hash) - OffCKB CLI
DESCRIPTION: Use this command to debug a CKB transaction by providing its transaction hash. The OffCKB CLI will verify all scripts within the transaction and print detailed execution results, including cycle consumption.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_23

LANGUAGE: bash
CODE:
```
offckb debug <transaction-hash>
```

----------------------------------------

TITLE: Deploying CKB Scripts (Duktape, HTLC) using Node.js
DESCRIPTION: This Node.js script deploys the Duktape binary and a custom JavaScript script (like an HTLC script) onto a CKB dev chain. It reads the binaries from files, calculates required capacities, constructs a transaction with outputs for the scripts and change, signs it with a private key, and sends it to a CKB node, outputting the transaction hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_19

LANGUAGE: JavaScript
CODE:
```
#!/usr/bin/env node

const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

if (process.argv.length !== 6) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <js script> <private key> <node URL>`)
  process.exit(1)
}

const duktapeBinary = fs.readFileSync(process.argv[2])
const jsScript = fs.readFileSync(process.argv[3])

const privateKey = process.argv[4]
const nodeUrl = process.argv[5]

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const duktapeBinaryCapacity = BigInt(duktapeBinary.length) * 100000000n + 4100000000n
  const jsScriptCapacity = BigInt(jsScript.length) * 100000000n + 4100000000n

  const outputs = [
    {
      lock: {
        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
        hashType: 'data',
        args: '0x'
      },
      type: null,
      capacity: '0x' + duktapeBinaryCapacity.toString(16)
    },
    {
      lock: {
        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
        hashType: 'data',
        args: '0x'
      },
      type: null,
      capacity: '0x' + jsScriptCapacity.toString(16)
    },
    {
      lock: lockScript,
      type: null,
      capacity: '0x' + (totalCapacity - jsScriptCapacity - duktapeBinaryCapacity - fee).toString(16)
    }
  ]
  const outputsData = [
    utils.bytesToHex(duktapeBinary),
    utils.bytesToHex(jsScript),
    '0x'
  ]

  const transaction = {
    version: '0x0',
    cellDeps: [
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs,
    witnesses: [
      {
        lock: '',
        inputType: '',
        outputType: ''
      }
    ],
    outputsData
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)

  const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

  console.log(`Transaction hash: ${txHash}`)
  fs.writeFileSync('deploy_scripts_result.txt', txHash)
}

run()
```

----------------------------------------

TITLE: Starting Local CKB Devnet with offckb (Shell)
DESCRIPTION: Execute this command using the installed offckb tool to start a local CKB development network, which provides a blockchain environment for testing dApp examples.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/README.md#_snippet_2

LANGUAGE: Shell
CODE:
```
offckb node
```

----------------------------------------

TITLE: Install Lumos SDK - pnpm - Bash
DESCRIPTION: Adds the `@ckb-lumos/lumos` package as a dependency to the current project using the pnpm package manager. This makes the Lumos library available for use in the project.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_2

LANGUAGE: Bash
CODE:
```
pnpm add @ckb-lumos/lumos
```

----------------------------------------

TITLE: Implementing CKB HTLC Script Logic in JavaScript
DESCRIPTION: This JavaScript code implements the core logic for a CKB HTLC script. It uses the Molecule library to deserialize script arguments and witness data, which define the conditions for unlocking the funds (either providing a secret hash or waiting for a timelock). It also includes helper functions for data conversion and interacts with the CKB environment via CKB built-in functions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_18

LANGUAGE: javascript
CODE:
```
const { Molecule } = require('molecule-javascript')
const schema = require('../schema/blockchain-combined.json')

const names = schema.declarations.map(declaration => declaration.name)
const scriptTypeIndex = names.indexOf('Script')
const scriptType = new Molecule(schema.declarations[scriptTypeIndex])

// Write your script logic here.
const customSchema = require('./htlc-combined.json')
const customNames = customSchema.declarations.map(d => d.name)

const htlcArgsIndex = customNames.indexOf('HtlcArgs')
const htlcArgsType = new Molecule(customSchema.declarations[htlcArgsIndex])

function bytesToHex(b) {
  return "0x" + Array.prototype.map.call(
    new Uint8Array(b),
    function(x) {
      return ('00' + x.toString(16)).slice(-2)
    }
  ).join('')
}

function hexStringArrayToString(a) {
  let s = "";
  for (let i = 0; i < a.length; i++) {
    s = s + String.fromCharCode(parseInt(a[i]))
  }
  return s
}

function hexStringArrayToHexString(a) {
  let s = "0x";
  for (let i = 0; i < a.length; i++) {
    s = s + a[i].substr(2)
  }
  return s
}

function parseLittleEndianHexStringArray(a) {
  let v = 0
  const l = a.length
  for (let i = 0; i < l; i++) {
    v = (v << 8) | parseInt(a[l - i - 1])
  }
  return v
}

const current_script = scriptType.deserialize(bytesToHex(CKB.load_script(0)))
const args = hexStringArrayToHexString(current_script[2][1])
const htlcArgs = htlcArgsType.deserialize(args)

// Load and parse witness data using the same method as above
const htlcWitnessIndex = customNames.indexOf('HtlcWitness')
const htlcWitnessType = new Molecule(customSchema.declarations[htlcWitnessIndex])

const rawWitness = CKB.load_witness(0, 0, CKB.SOURCE.GROUP_INPUT)
if (typeof rawWitness === 'number') {
  throw new Error(`Invalid response when loading witness: ${rawWitness}`)
}
const htlcWitness = htlcWitnessType.deserialize(bytesToHex(rawWitness))

let lockHashToMatch;
if (htlcWitness[0][1].length > 0) {
  // Test secret string hash
  const crc32 = require('crc32')
  const hash = '0x' + crc32(hexStringArrayToString(htlcWitness[0][1]))
  if (hash !== hexStringArrayToHexString(htlcArgs[2][1])) {
    throw new Error(`Invalid secret string!`)
  }
  lockHashToMatch = hexStringArrayToHexString(htlcArgs[0][1])
} else {
  // Test header block
  const headerTypeIndex = names.indexOf('Header')
  const headerType = new Molecule(schema.declarations[headerTypeIndex])

  // Load header for current input first
  const rawInputHeader = CKB.load_header(0, 0, CKB.SOURCE.GROUP_INPUT)
  if (typeof rawWitness === 'number') {
    throw new Error(`Invalid response when loading input header: ${rawInputHeader}`)
  }
  const inputHeader = headerType.deserialize(bytesToHex(rawInputHeader))
  const inputHeaderNumber = parseLittleEndianHexStringArray(inputHeader[0][1][3][1])

  const targetHeaderIndex = parseLittleEndianHexStringArray(htlcWitness[1][1])
  const rawTargetHeader = CKB.load_header(0, targetHeaderIndex,
                                          CKB.SOURCE.HEADER_DEP)
  if (typeof rawTargetHeader === 'number') {
    throw new Error(`Invalid response when loading target header: ${rawTargetHeader}`)
  }
  const targetHeader = headerType.deserialize(bytesToHex(rawTargetHeader))
  const targetHeaderNumber = parseLittleEndianHexStringArray(targetHeader[0][1][3][1])

  if (targetHeaderNumber < inputHeaderNumber + 100) {
    throw new Error(`Timeout period has not reached!`)
  }
  lockHashToMatch = hexStringArrayToHexString(htlcArgs[1][1])
}

// Now we know which lock hash to test against, we look for an input cell
// with the specified lock hash
let i = 0
while (true) {
  const rawHash = CKB.load_cell_by_field(0, i, CKB.SOURCE.INPUT, CKB.CELL.LOCK_HASH)
  if (rawHash == CKB.CODE.INDEX_OUT_OF_BOUND) {
    throw new Error(`Cannot find input cell using lock hash ${lockHashToMatch}`)
  }
  if (typeof rawHash === 'number') {
    throw new Error(`Invalid response when loading input cell: ${rawHash}`)
  }
  if (bytesToHex(rawHash) == lockHashToMatch) {
    break
  }
  i += 1
}
```

----------------------------------------

TITLE: Deploy Scripts to Devnet (Shell)
DESCRIPTION: Deploys the built CKB scripts to the Devnet using the `offckb` command-line tool. This command is executed from the frontend workspace.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_11

LANGUAGE: sh
CODE:
```
offckb deploy --network devnet
```

----------------------------------------

TITLE: Creating HTLC-Locked Cell on CKB (JavaScript)
DESCRIPTION: This script is intended to create a cell on the CKB blockchain that is locked by the previously deployed HTLC script. It reads the Duktape binary to calculate its hash, takes the deployment transaction hash, private key, node URL, and two lock hashes (A and B) as input. The provided snippet initializes the CKB SDK and loads the secp256k1 dependency, but the transaction construction and sending logic is incomplete.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_19

LANGUAGE: JavaScript
CODE:
```
#!/usr/bin/env node

const { Molecule } = require('molecule-javascript')
const crc32 = require('crc32')
const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 8) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <deployed tx hash> <private key> <node URL> <lock hash A> <lock hash B>`)
  process.exit(1)
}

const duktapeBinary = fs.readFileSync(process.argv[2])
const duktapeHash = blake2b(duktapeBinary)

const deployedTxHash = process.argv[3]
const privateKey = process.argv[4]
const nodeUrl = process.argv[5]
const lockHashA = process.argv[6]
const lockHashB = process.argv[7]

function hexStringToHexStringArray(s) {
  let arr = []
  for (let i = 2; i < s.length; i += 2) {
    arr.push('0x' + s.substr(i, 2))
  }
  return arr
}

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

```

----------------------------------------

TITLE: Calculate Max Nervos DAO Deposit Amount (TypeScript)
DESCRIPTION: This snippet calculates the maximum amount of CKB that can be deposited into the Nervos DAO for the current signer. It constructs a transaction, adds necessary cell dependencies, completes inputs, fetches the current fee rate, adjusts the fee, and then determines the maximum capacity available for the deposit output.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_25

LANGUAGE: TypeScript
CODE:
```
outputsData: ["00".repeat(8)],
            });
            await tx.addCellDepsOfKnownScripts(
              signer.client,
              ccc.KnownScript.NervosDao
            );

            await tx.completeInputsAll(signer);
            const feeRate = await signer.client.getFeeRate();
            setFeeRate(feeRate);
            await tx.completeFeeChangeToOutput(signer, 0, feeRate);

            const amount = ccc.fixedPointToString(tx.outputs[0].capacity);
            log("You can deposit at most", amount, "CKB");
            setAmount(amount);
          }}
```

----------------------------------------

TITLE: Load Values from Witness (Rust)
DESCRIPTION: Loads two numerical values, `v1` and `v2`, from the transaction's witness field for use in the script logic. This is the first step in the script execution.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/ckb-vs-btc.mdx#_snippet_7

LANGUAGE: Rust
CODE:
```
const v1 = load_value1_from_witness(); // number 3
const v2 = load_value2_from_witness(); // number 5
```

----------------------------------------

TITLE: Defining the CKB-VM write Function Signature (Rust)
DESCRIPTION: Signature for the `write` syscall in CKB-VM. It writes data from a buffer to a specified file descriptor, returning the number of bytes successfully written.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-direct-cross-script-calling.mdx#_snippet_4

LANGUAGE: Rust
CODE:
```
pub fn write(fd: u64, buffer: &[u8]) -> Result<usize, SysError>;
```

----------------------------------------

TITLE: Debugging CKB Script with ckb-debugger (Bash)
DESCRIPTION: Initiates the `ckb-debugger` tool to debug a specific script within a transaction, targeting a particular cell by index and type (`output`, `type`). Requires a full transaction dump file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_9

LANGUAGE: Bash
CODE:
```
ckb-debugger --tx-file full-failed-tx.json --cell-index 0 --cell-type output --script-group-type type
```

----------------------------------------

TITLE: Compile CKB Script with Docker (Bash)
DESCRIPTION: Demonstrates compiling a CKB script (`carrot.c`) into a RISC-V executable (`carrot`) using a pre-built Docker image containing the necessary GCC toolchain. It shows listing files, running the docker container, navigating inside, compiling, exiting, and verifying the output file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_3

LANGUAGE: bash
CODE:
```
$ ls
carrot.c  ckb_consts.h  ckb_syscalls.h
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:xenial bash
root@dc2c0c209dcd:/# cd /code
root@dc2c0c209dcd:/code# riscv64-unknown-elf-gcc -Os carrot.c -o carrot
root@dc2c0c209dcd:/code# exit
exit
$ ls
carrot*  carrot.c  ckb_consts.h  ckb_syscalls.h
```

----------------------------------------

TITLE: Import and Use Deployed Scripts (TypeScript)
DESCRIPTION: Demonstrates how to import the `offckb.config` file and access details of deployed scripts, such as `cellDeps`, `codeHash`, and `hashType`, to construct a CKB `Script` object for use in the frontend dApp.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_13

LANGUAGE: typescript
CODE:
```
import offckb from "offckb.config";

const myScriptDeps: CellDep[] = offCKB.myScripts["YOUR_SCRIPT_NAME"]!.cellDeps;
const myScript: Script = {
  codeHash: offCKB.myScripts["hash-lock"]!.codeHash,
  hashType: offCKB.myScripts["hash-lock"]!.hashType,
  args: lockArgs,
};
```

----------------------------------------

TITLE: Implementing Unique Type Script Logic in C
DESCRIPTION: This C code implements the logic for a unique type script on CKB. It checks if there is more than one output cell with the current script, if there is exactly one input cell with the script, and finally verifies if the script's arguments match the OutPoint of the first input cell in the transaction. It uses CKB syscalls to load cell data, input data, and the script itself, and uses MolReader for parsing the script structure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-6.md#_snippet_0

LANGUAGE: C
CODE:
```
#include "blockchain.h"
#include "ckb_syscalls.h"

#define INPUT_SIZE 128
#define SCRIPT_SIZE 32768

int main() {
  uint64_t len = 0;
  int ret = ckb_load_cell(NULL, &len, 0, 1, CKB_SOURCE_GROUP_OUTPUT);
  if (ret != CKB_INDEX_OUT_OF_BOUND) {
    return -1;  /* 1 */
  }

  len = 0;
  ret = ckb_load_cell(NULL, &len, 0, 0, CKB_SOURCE_GROUP_INPUT);
  if (ret != CKB_INDEX_OUT_OF_BOUND) {
    return 0;  /* 2 */
  }

  /* 3 */
  unsigned char input[INPUT_SIZE];
  uint64_t input_len = INPUT_SIZE;
  ret = ckb_load_input(input, &input_len, 0, 0, CKB_SOURCE_INPUT);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (input_len > INPUT_SIZE) {
    return -100;
  }

  unsigned char script[SCRIPT_SIZE];
  len = SCRIPT_SIZE;
  ret = ckb_load_script(script, &len, 0);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (len > SCRIPT_SIZE) {
    return -101;
  }
  mol_seg_t script_seg;
  script_seg.ptr = (uint8_t *)script;
  script_seg.size = len;

  if (MolReader_Script_verify(&script_seg, false) != MOL_OK) {
    return -102;
  }

  mol_seg_t args_seg = MolReader_Script_get_args(&script_seg);
  mol_seg_t args_bytes_seg = MolReader_Bytes_raw_bytes(&args_seg);

  if ((input_len == args_bytes_seg.size) &&
      (memcmp(args_bytes_seg.ptr, input, input_len) == 0)) {
    /* 4 */
    return 0;
  }
  return -103;
}
```

----------------------------------------

TITLE: Building a CKB Transaction with TransactionBuilder (Java)
DESCRIPTION: Demonstrates using the CKB-SDK-Java TransactionBuilder to construct a CKB transfer transaction, specifying sender, receiver, amount, and fee rate.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_6

LANGUAGE: Java
CODE:
```
String sender = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r";
String receiver = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqg958atl2zdh8jn3ch8lc72nt0cf864ecqdxm9zf";
Iterator<TransactionInput> iterator = new InputIterator(sender);
TransactionBuilderConfiguration configuration = new TransactionBuilderConfiguration(Network.TESTNET);
configuration.setFeeRate(1000);
TransactionWithScriptGroups txWithGroups = new CkbTransactionBuilder(configuration, iterator)
    .addOutput(receiver, 50100000000L)
    .setChangeOutput(sender)
    .build();
```

----------------------------------------

TITLE: Transferring Custom Token (xUDT) Function Signature in TypeScript
DESCRIPTION: This is the function signature for transferring a custom token (xUDT) to another address. It takes the token issuer's arguments, the sender's private key, the amount to transfer, and the receiver's address as input.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_6

LANGUAGE: typescript
CODE:
```
export async function transferTokenToAddress(
  udtIssuerArgs: string,
  senderPrivKey: string,
  amount: string,
  receiverAddress: string,
){...}
```

----------------------------------------

TITLE: Deserialize HtlcArgs from Script Arguments (JavaScript)
DESCRIPTION: Specifically shows how to use the `HtlcArgs` Molecule type, previously loaded from the schema, to deserialize the extracted script arguments string into the structured `htlcArgs` object.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_14

LANGUAGE: javascript
CODE:
```
const htlcArgs = htlcArgsType.deserialize(args)
```

----------------------------------------

TITLE: Configuring CKB CCC Provider (TypeScript)
DESCRIPTION: Shows how to wrap the application with the `ccc.Provider` from `@ckb-ccc/connector-react` to configure wallet connection options, including network selection (mainnet/testnet) and custom styling for the connector UI.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_11

LANGUAGE: typescript
CODE:
```
import React from "react";
import { ccc } from "@ckb-ccc/connector-react";
import { CSSProperties } from "react";

export function LayoutProvider({ children }: { children: React.ReactNode }) {
  const defaultClient = React.useMemo(() => {
    return process.env.REACT_APP_IS_MAINNET === "true"
      ? new ccc.ClientPublicMainnet()
      : new ccc.ClientPublicTestnet();
  }, []);

  return (
    <ccc.Provider
      connectorProps={{
        style: {
          "--background": "#232323",
          "--divider": "rgba(255, 255, 255, 0.1)",
          "--btn-primary": "#2D2F2F",
          "--btn-primary-hover": "#515151",
          "--btn-secondary": "#2D2F2F",
          "--btn-secondary-hover": "#515151",
          "--icon-primary": "#FFFFFF",
          "--icon-secondary": "rgba(255, 255, 255, 0.6)",
          color: "#ffffff",
          "--tip-color": "#666"
        } as CSSProperties,
      }}
      defaultClient={defaultClient}
      clientOptions={[
        {
          name: "CKB Testnet",
          client: new ccc.ClientPublicTestnet(),
        },
        {
          name: "CKB Mainnet",
          client: new ccc.ClientPublicMainnet(),
        },
      ]}
    >
      {children}
    </ccc.Provider>
  );
}
```

----------------------------------------

TITLE: Create Script Type Object from Deployed Data Hash
DESCRIPTION: This JavaScript snippet shows how to create the `carrotTypeScript` object required by CKB transactions. It calculates the Blake2b hash of the deployed script binary data using `lumos.utils.ckbHash` and the `@ckb-lumos/lumos/codec` bytes utility. The `hashType` is set to "data" to indicate the script is referenced by the hash of its data, and `args` is set to empty bytes as the script doesn't require arguments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_6

LANGUAGE: js
CODE:
```
> const bytes = require("@ckb-lumos/lumos/codec").bytes;
> const carrotDataHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
> const carrotTypeScript =  {
  codeHash: carrotDataHash,
  hashType: "data",
  args: "0x"
};
```

----------------------------------------

TITLE: Generate Molecule Bindings (File) - OffCKB CLI
DESCRIPTION: Generate code bindings for a specific programming language from a single Molecule schema (.mol) file. Specify the input schema file, the desired output file path, and the target language.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_26

LANGUAGE: bash
CODE:
```
offckb mol --schema <path/to/mol/file> --output <path/to/output/file> --lang <lang>
```

----------------------------------------

TITLE: Define CKB Contract Errors in Rust
DESCRIPTION: Defines a custom error enum `Error` for a CKB contract, including standard system errors and potential custom errors. Implements `From<SysError>` to convert CKB system errors into the custom error type.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_11

LANGUAGE: Rust
CODE:
```
use ckb_std::error::SysError;

#[cfg(test)]
extern crate alloc;

#[repr(i8)]
pub enum Error {
    IndexOutOfBound = 1,
    ItemMissing,
    LengthNotEnough,
    Encoding,
    WaitFailure,
    InvalidFD,
    OtherEndClose,
    MaxVmSpawned,
    MaxFdCreated,
    // Add customized errors here...
}

impl From<SysError> for Error {
    fn from(err: SysError) -> Self {
        match err {
            SysError::IndexOutOfBound => Self::IndexOutOfBound,
            SysError::ItemMissing => Self::ItemMissing,
            SysError::LengthNotEnough(_) => Self::LengthNotEnough,
            SysError::Encoding => Self::Encoding,
            SysError::WaitFailure => Self::WaitFailure,
            SysError::InvalidFd => Self::InvalidFD,
            SysError::OtherEndClosed => Self::OtherEndClose,
            SysError::MaxVmsSpawned => Self::MaxVmSpawned,
            SysError::MaxFdsCreated => Self::MaxFdsCreated,
            SysError::Unknown(err_code) => panic!("unexpected sys error {}", err_code),
        }
    }
}
```

----------------------------------------

TITLE: Omnilock Script Structure
DESCRIPTION: This snippet illustrates the structure of the Omnilock Lock Script, detailing its components: the code hash, hash type, and the arguments field which includes the authentication (auth) and additional Omnilock arguments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_0

LANGUAGE: CKB Script Structure
CODE:
```
Code hash: Omnilock script code hash
Hash type: Omnilock script hash type
Args: <21 byte auth> <Omnilock args>
```

----------------------------------------

TITLE: Applying Lumos Patches for JoyID (TypeScript)
DESCRIPTION: Imports and applies necessary patches from `@ckb-ccc/lumos-patches` to enable JoyID wallet support within Lumos-based CKB transaction composition. This step should be performed before using Lumos and replaces the need for `@ckb-lumos/joyid`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_1

LANGUAGE: TypeScript
CODE:
```
import { generateDefaultScriptInfos } from "@ckb-ccc/lumos-patches";

// Before using Lumos. You don't need @ckb-lumos/joyid anymore.
registerCustomLockScriptInfos(generateDefaultScriptInfos());
```

----------------------------------------

TITLE: Run CKB Debugger with Dump File (Optimized)
DESCRIPTION: Executes the script using the previously generated `dump0.bin` as input via `runner.rb` and `ckb-debugger`. This command demonstrates the reduced cycle consumption after applying optimizations, including skipping cleanup.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-9.md#_snippet_17

LANGUAGE: Shell
CODE:
```
$ RUST_LOG=debug ./runner.rb dump0.bin script.bin
Executing: ckb-standalone-debugger/bins/target/release/ckb-debugger --tx-file tx.json --script-group-type lock -i 0 -e input
DEBUG:<unknown>: script group: Byte32(0x0e948e69dd75f2d6676048569073afe4ec2b284144bbe33a6216b13171606d18) DEBUG OUTPUT: 0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947c219351b150b900e50a7039f1e448b844110927e5fd9bd30425806cb8ddff1fd970dd9a8
Run result: Ok(0)
Total cycles consumed: 3903352
Transfer cycles: 96994, running cycles: 3806358
```

----------------------------------------

TITLE: Prepare CKB Transaction for Duktape Deployment (Lumos)
DESCRIPTION: Demonstrates how to use Node.js and the Lumos library to read the compiled Duktape binary file and initialize a transaction skeleton for deploying the binary onto the CKB blockchain, including adding transfer details.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_14

LANGUAGE: JavaScript
CODE:
```
> const data = fs.readFileSync("../ckb-duktape/build/duktape");
> data.byteLength
291440
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"292000" + "00000000");
```

----------------------------------------

TITLE: Transfer Function Signature (TypeScript)
DESCRIPTION: This is the function signature for the `transfer` function. It indicates that the function is asynchronous, takes the recipient address, amount in CKB, and the sender's private key as input, and returns a promise resolving to a string (likely the transaction hash).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_3

LANGUAGE: TypeScript
CODE:
```
export async function transfer(
  toAddress: string,
  amountInCKB: string,
  signerPrivateKey: string
): Promise<string>;
```

----------------------------------------

TITLE: Get Block Information (Go)
DESCRIPTION: Shows how to call the `GetBlock` JSON-RPC method on the CKB client to retrieve details for a specific block using its hash. It requires a `context.Context` and the block hash as input.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_5

LANGUAGE: Go
CODE:
```
block, err := ckbClient.GetBlock(context.Background(), types.HexToHash("0x77fdd22f6ae8a717de9ae2b128834e9b2a1424378b5fc95606ba017aab5fed75"))
```

----------------------------------------

TITLE: Compile C Code for CKB RISC-V Target
DESCRIPTION: Shell commands using a Docker container with the CKB RISC-V GNU toolchain to compile the three different C implementations (`fib_wabt_main.c`, `fib_wavm_main.c`, `fib_native_main.c`) into executable binaries (`fib_wabt`, `fib_wavm`, `fib_native`). It also applies a patcher utility to the WAVM binary.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-8.md#_snippet_7

LANGUAGE: Shell
CODE:
```
cd $TOP
sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20191209 bash
root@7f24745ca702:/# cd /code
root@7f24745ca702:/code# riscv64-unknown-elf-gcc -O3 -I ckb-c-stdlib -I wavm-aot-generator -I wabt/wasm2c fib_wabt_main.c fib.c wabt/wasm2c/wasm-rt-impl.c -o fib_wabt
root@7f24745ca702:/code# riscv64-unknown-elf-gcc -O3 -I ckb-c-stdlib -I wavm-aot-generator -I wabt/wasm2c fib_wavm_main.c wavm-aot-generator/abi/riscv64_runtime.S fib_precompiled.o -o fib_wavm -Wl,-T wavm-aot-generator/abi/riscv64.lds
root@7f24745ca702:/code# riscv64-unknown-elf-gcc -O3 -I ckb-c-stdlib -I wavm-aot-generator -I wabt/wasm2c fib_native_main.c -o fib_native
root@7f24745ca702:/code# exit
exit
ckb-binary-patcher/target/release/ckb-binary-patcher -i fib_wavm -o fib_wavm_patched
```

----------------------------------------

TITLE: Define Custom Error Enum for CKB Script Rust
DESCRIPTION: This Rust code defines a custom `Error` enum used by the CKB script. It includes standard system errors from `ckb_std::error::SysError` and adds a specific `CarrotAttack` error variant. It also provides an implementation of `From<SysError>` to facilitate converting standard system errors into the custom error type for consistent error handling within the script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_8

LANGUAGE: Rust
CODE:
```
use ckb_std::error::SysError;

#[cfg(test)]
extern crate alloc;

#[repr(i8)]
pub enum Error {
    IndexOutOfBound = 1,
    ItemMissing,
    LengthNotEnough,
    Encoding,
    // Add customized errors here...
    CarrotAttack,
}

impl From<SysError> for Error {
    fn from(err: SysError) -> Self {
        match err {
            SysError::IndexOutOfBound => Self::IndexOutOfBound,
            SysError::ItemMissing => Self::ItemMissing,
            SysError::LengthNotEnough(_) => Self::LengthNotEnough,
            SysError::Encoding => Self::Encoding,
            SysError::Unknown(err_code) => panic!("unexpected sys error {}", err_code),
        }
    }
}
```

----------------------------------------

TITLE: Convert Public Key to CKB Address (Java)
DESCRIPTION: Shows how to convert a given elliptic curve public key (as a byte array) into a `secp256k1_blake160` CKB address using the `generateSecp256K1Blake160SignhashAllScript` method and encoding it for the testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_9

LANGUAGE: Java
CODE:
```
// The public key sent is an elliptic curve public key of compressed format - a 65-length hex (not include hex prefix 0x).
byte[] publicKey = Numeric.hexStringToByteArray("0x24a501efd328e062c8675f2365970728c859c592beeefd6be8ead3d901330bc01");
Script script = Script.generateSecp256K1Blake160SignhashAllScript(publicKey);
Address address = new Address(script, Network.TESTNET);
System.out.println(address.encode());
```

----------------------------------------

TITLE: Decode Spore DOB via RPC Request (Bash)
DESCRIPTION: Illustrates how to send a JSON RPC request to the local DOB decoding server using `curl` to decode a specific Spore DOB by its ID.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/spore-dob-0.mdx#_snippet_7

LANGUAGE: Bash
CODE:
```
echo '{
  "id": 2,
  "jsonrpc": "2.0",
  "method": "dob_decode",
  "params": [
      "<spore_id in hex format without 0x prefix>"
  ]
}' \
| curl -H 'content-type: application/json' -d @- \
http://localhost:8090
```

----------------------------------------

TITLE: Defining a 4-byte Array for Uint32 (Molecule Schema)
DESCRIPTION: Defines a fixed-size array type named `Uint32` that contains exactly 4 `byte` elements. This type is commonly used to represent a 32-bit unsigned integer. The example shows the integer `0x01020304` serialized in little-endian format as `04 03 02 01`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/encoding-specs.mdx#_snippet_1

LANGUAGE: Molecule Schema
CODE:
```
array Uint32 [byte; 4];
```

----------------------------------------

TITLE: Setting Network Environment Variable (Shell)
DESCRIPTION: This shell command sets the NETWORK environment variable to 'testnet'. This is typically used to configure a dApp to connect to the Nervos Testnet instead of the default local development environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/_SwitchToTestnet.mdx#_snippet_0

LANGUAGE: sh
CODE:
```
export NETWORK=testnet
```

----------------------------------------

TITLE: Stepping Through Script Execution in GDB
DESCRIPTION: Illustrates a GDB debugging session, including setting a breakpoint at 'main', continuing execution, stepping through lines ('n'), inspecting variable values ('p'), and identifying a logic error related to the interpretation of memcmp's return value.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_9

LANGUAGE: GDB
CODE:
```
(gdb) b main
Breakpoint 1 at 0x106b0: file carrot.c, line 6.
(gdb) c
Continuing.

Breakpoint 1, main (argc=0, argv=0x400000) at carrot.c:6
6         size_t index = 0;
(gdb) n
7         uint64_t len = 0;
(gdb) n
11          len = 6;
(gdb) n
12          memset(buffer, 0, 6);
(gdb) n
13          ret = ckb_load_cell_data(buffer, &len, 0, index, CKB_SOURCE_OUTPUT);
(gdb) n
14          if (ret == CKB_INDEX_OUT_OF_BOUND) {
(gdb) n
18          int cmp = memcmp(buffer, "carrot", 6);
(gdb) n
19          if (cmp) {
(gdb) p cmp
$1 = -99
(gdb) p buffer[0]
$2 = 0 '\000'
(gdb) n
20            return -1;
```

----------------------------------------

TITLE: Native C Implementation (fib_native_main.c)
DESCRIPTION: C code providing a native implementation of the Fibonacci function and a main function for running it directly on CKB. It includes `ckb_syscalls.h`, implements the `fib` function in C, loads input from witness data, and calls the native `fib` function.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-8.md#_snippet_6

LANGUAGE: C
CODE:
```
cd $TOP
cat << EOF > fib_native_main.c
#include "ckb_syscalls.h"

int32_t fib(int32_t n) {
  int32_t a = 0;
  int32_t b = 1;

  for (int32_t i = 0; i < n; i++) {
    int32_t t = a + b;
    a = b;
    b = t;
  }

  return b;
}

int main() {
  uint32_t value;
  uint64_t len = 4;
  int ret = ckb_load_witness((void*) &value, &len, 0, 0,
                             CKB_SOURCE_GROUP_INPUT);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (len < 4) {
    return -1;
  }

  return fib(value);
}
EOF
```

----------------------------------------

TITLE: Listing Pre-funded Devnet Accounts (Bash)
DESCRIPTION: This command lists the pre-funded accounts available in the Devnet genesis block. Each account is funded with a large capacity and includes the private key, public key, lock script details, and address. This is useful for obtaining private keys for testing. The output displays a JSON array of account objects.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/_StartDevnet.mdx#_snippet_1

LANGUAGE: bash
CODE:
```
offckb accounts
```

----------------------------------------

TITLE: Implement createSporeDOB Function
DESCRIPTION: Provides the full TypeScript implementation of the `createSporeDOB` function using the Spore-SDK. It demonstrates creating a wallet from a private key, building a Spore creation transaction with specified content type and content, and finally signing and sending the transaction to the network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-dob.mdx#_snippet_4

LANGUAGE: ts
CODE:
```
export async function createSporeDOB(
  privkey: string,
  content: Uint8Array
): Promise<{ txHash: string; outputIndex: number }> {
  const wallet = createDefaultLockWallet(privkey);

  const { txSkeleton, outputIndex } = await createSpore({
    data: {
      contentType: "image/jpeg",
      content,
    },
    toLock: wallet.lock,
    fromInfos: [wallet.address],
    config: SPORE_CONFIG,
  });

  const txHash = await wallet.signAndSendTransaction(txSkeleton);
  console.log(`Spore created at transaction: ${txHash}`);
  console.log(
    `Spore ID: ${
      txSkeleton.get("outputs").get(outputIndex)!.cellOutput.type!.args
    }`
  );
  return { txHash, outputIndex };
}
```

----------------------------------------

TITLE: Initialize and Run CKB Full Node (Shell)
DESCRIPTION: This command initializes the CKB node configuration for the Mainnet and then starts the CKB full node process. It's used to set up and run a full node that syncs the entire blockchain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/glossary.md#_snippet_0

LANGUAGE: Shell
CODE:
```
ckb init --chain Mainnet && ckb run
```

----------------------------------------

TITLE: Import CCC Core Object
DESCRIPTION: Imports the main `ccc` object from the installed CCC package. This object encapsulates most of the SDK's functionalities.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_4

LANGUAGE: tsx
CODE:
```
import { ccc } from "@ckb-ccc/<package-name>";
```

----------------------------------------

TITLE: Completing CKB Transaction Inputs and Fee (TypeScript)
DESCRIPTION: This snippet continues the `transfer` function implementation. It uses the signer to automatically complete the transaction inputs by selecting sufficient live cells and calculates/completes the transaction fee. Requires the transaction object (`tx`) and the signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/transfer-ckb.mdx#_snippet_5

LANGUAGE: TypeScript
CODE:
```
//....

// Complete missing parts for transaction
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);
```

----------------------------------------

TITLE: Generate New CKB Address (Java)
DESCRIPTION: Illustrates how to generate a new CKB address using the `secp256k1_blake160` script by creating a new EC key pair and encoding the resulting script as an address for the testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_8

LANGUAGE: Java
CODE:
```
// Generate a random address
ECKeyPair keyPair = Keys.createEcKeyPair();
Script script = Script.generateSecp256K1Blake160SignhashAllScript(keyPair));
Address address = new Address(script, Network.TESTNET);
System.out.println(address.encode());
```

----------------------------------------

TITLE: Parsing CKB Address (Rust)
DESCRIPTION: This snippet demonstrates how to parse a CKB address string using the `ckb-sdk` crate in Rust. It requires the `ckb_sdk` and `ckb_types` crates. It takes a Bech32 encoded address string as input and outputs the parsed `Address` object, from which the network and script can be extracted.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/rust.mdx#_snippet_9

LANGUAGE: Rust
CODE:
```
use ckb_sdk::types::Address;
use ckb_types::packed::Script;
use std::str::FromStr;

let addr_str = "ckb1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqgvf0k9sc40s3azmpfvhyuudhahpsj72tsr8cx3d";
let addr = Address::from_str(addr_str).unwrap();
let _network = addr.network();
let _script: Script = addr.payload().into();
```

----------------------------------------

TITLE: Constructing and Sending Transaction in OffCKB REPL
DESCRIPTION: A sequence of commands executed within the offckb REPL to construct a CKB transaction, set output capacity and lock script, add cell dependencies from deployed scripts, complete inputs and fee using a signer, and finally send the transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_23

LANGUAGE: OffCKB REPL (JS/CKB SDK)
CODE:
```
OffCKB > let amountInCKB = ccc.fixedPointFrom(63);
OffCKB > let caller = myScripts['caller'];
OffCKB > let lockScript = new ccc.Script(caller.codeHash, caller.hashType, "0x00");
OffCKB > let tx = ccc.Transaction.from({
...   outputs: [
...     {
...       capacity: ccc.fixedPointFrom(amountInCKB),
...       lock: lockScript,
...     },
...   ],
...   cellDeps: [
...     ...myScripts["callee"].cellDeps.map(c => c.cellDep),
...     ...myScripts['caller'].cellDeps.map(c => c.cellDep),
...   ]}
... );
OffCKB > let signer = new ccc.SignerCkbPrivateKey(client, accounts[0].privkey);
OffCKB > await tx.completeInputsByCapacity(signer);
1
OffCKB > await tx.completeFeeBy(signer, 1000);
[ 0, true ]
OffCKB > await signer.sendTransaction(tx)
'0x252305141e6b7db81f7da94b098493a36b756fe9d5d4436c9d7c966882bc0b38'
```

----------------------------------------

TITLE: Installing and Running ckb-standalone-debugger (Bash)
DESCRIPTION: Installs the ckb-standalone-debugger from its Git repository using Cargo and then launches it in GDB mode, listening on port 2000, specifying the transaction dump file and the target cell/script group for debugging.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_6

LANGUAGE: Bash
CODE:
```
cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger
ckb-debugger --mode gdb --gdb-listen 0.0.0.0:2000 --tx-file carrot.json --cell-index 0 --cell-type output --script-group-type type
```

----------------------------------------

TITLE: Creating Initial UDT Cell using Lumos
DESCRIPTION: JavaScript code using Lumos to create the first cell for the UDT, which will hold the initial token supply. It demonstrates how to build the transaction skeleton and extract the `outPointHex` needed as an argument for the UDT script during creation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_5

LANGUAGE: javascript
CODE:
```
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton, [wallet.address], wallet2.address, "1820" + "00000000");
const blockchain = require("@ckb-lumos/base").blockchain;
const outPointBuf = blockchain.OutPoint.pack(txSkeleton.get("inputs").first().outPoint);
const outPointHex = Buffer.from(outPointBuf).toString("hex");
outPointHex;
```

----------------------------------------

TITLE: Get Tip Header via RPC (Bash/JSON)
DESCRIPTION: Demonstrates how to call the get_tip_header RPC method using curl to query the latest block information from the CKB node via the Nginx proxy. Shows the expected JSON result structure. Requires curl and the Nginx proxy to be running.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/run-public-rpc-node.mdx#_snippet_4

LANGUAGE: bash
CODE:
```
echo '{
    "id": 2,
    "jsonrpc": "2.0",
    "method": "get_tip_header",
    "params": []
}' \
| tr -d '\n' \
| curl -H 'content-type: application/json' -d @- \
http://192.168.1.100:80
```

LANGUAGE: json
CODE:
```
{
  "jsonrpc": "2.0",
  "result": {
    "compact_target": "0x1d090fbe",
    "dao": "0xba17553fab3db84154bc4aa9f09b2600e826a2b0df99010400ed51b4686b5808",
    "epoch": "0x7080687001539",
    "extra_hash": "0x0000000000000000000000000000000000000000000000000000000000000000",
    "hash": "0x7a46e779a3fc2d5b55c82aad852e721b0097bf873927b9751409b1d185599ce4",
    "nonce": "0xd265e70dfd205dbbed33b29294121856",
    "number": "0x7037f2",
    "parent_hash": "0x3d105fe9ec60f138baa6623abd16af70ba1be90ad23d1943bcaa55d5f14fcb6f",
    "proposals_hash": "0x2581d1769886226a8c90ee99baf2d8696e24c7f6bb6751748ff8b4452f8006e5",
    "timestamp": "0x1847a2bfad2",
    "transactions_root": "0x28157a5962c4ae1d3e153b1d8d331e5fd3c158866287f5398ab7f7d38210dfb0",
    "version": "0x0"
  },
  "id": 2
}
```

----------------------------------------

TITLE: Debug Transaction Lock Script with CKB-Debugger
DESCRIPTION: Executes the lock script of the first input cell (index 0) from a local transaction JSON file using CKB-Debugger and shows the execution result and cycle consumption.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_4

LANGUAGE: sh
CODE:
```
$ ckb-debugger --tx-file mock_tx.json --cell-index 0 --cell-type input --script-group-type lock\n\nRun result: 0\nTotal cycles consumed: 1697297(1.6M)\nTransfer cycles: 12680(12.4K), running cycles: 1684617(1.6M)
```

----------------------------------------

TITLE: Start CKB Devnet with Specific Version
DESCRIPTION: Starts a local CKB development network node using the specified CKB version (e.g., 0.117.0) instead of the default. This allows testing against different CKB node versions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_4

LANGUAGE: bash
CODE:
```
offckb node 0.117.0
```

----------------------------------------

TITLE: CKB UDT Script Validation Logic (JavaScript)
DESCRIPTION: This JavaScript code snippet is part of a CKB User Defined Token (UDT) type script. It validates the transaction by checking the number of arguments, loading the first input's OutPoint, comparing it against a provided argument, and verifying that input and output coin amounts match, with a special case for initial token issuance.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_2

LANGUAGE: JavaScript
CODE:
```
if (CKB.ARGV.length !== 1) {
  throw "Requires only one argument!";
}

var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var input_udt_buffer = new ArrayBuffer(16);
var output_index = 0;
var output_coins = 0;
var output_udt_buffer = new ArrayBuffer(16);

while (true) {
  var result = CKB.load_cell_by_field(input_udt_buffer, 0, 16, input_index, CKB.SOURCE.INPUT, CKB.CELL_FIELD.DATA);
  if (result === -1) {
    break;
  }
  if (result !== 16) {
    throw "Invalid input UDT data length!";
  }
  var view = new DataView(input_udt_buffer);
  input_coins += view.getUint64(0, true);
  input_index += 1;
}

while (true) {
  var result = CKB.load_cell_by_field(output_udt_buffer, 0, 16, output_index, CKB.SOURCE.OUTPUT, CKB.CELL_FIELD.DATA);
  if (result === -1) {
    break;
  }
  if (result !== 16) {
    throw "Invalid output UDT data length!";
  }
  var view = new DataView(output_udt_buffer);
  output_coins += view.getUint64(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  if (!((input_index === 0) && (output_index === 1))) {
    throw "Invalid token issuing mode!";
  }
  var first_input = CKB.load_input(0, 0, CKB.SOURCE.INPUT);
  if (typeof first_input === "number") {
    throw "Cannot fetch the first input";
  }
  var hex_input_outpoint = Array.prototype.map
   .call(new Uint8Array(first_input), function (x) {
     return ("00" + x.toString(16)).slice(-2);
   })
   .join("")
   .slice(16); // remove the first 8 bytes of since
  var outpoint_arg = new TextDecoder().decode(CKB.ARGV[0]);
  if (outpoint_arg != hex_input_outpoint) {
    throw "Invalid creation argument!";
  }
}
```

----------------------------------------

TITLE: Calculate CKB Code Hash - Pseudocode
DESCRIPTION: This snippet provides the formula used to calculate the code hash in CKB. The `ckbhash` function, which implements the CKB-specific BLAKE2b hash algorithm, is applied to the binary data (`data`) of the code cell to produce its unique hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-calculate-code-hash.mdx#_snippet_0

LANGUAGE: Pseudocode
CODE:
```
ckbhash(data)
```

----------------------------------------

TITLE: Clone and Run CKB Token Dapp Locally
DESCRIPTION: Clones the repository containing the Dapp example, navigates to the example directory, and starts the application using yarn for local execution.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/xudt/README.md#_snippet_0

LANGUAGE: Shell
CODE:
```
git clone https://github.com/nervosnetwork/docs.nervos.org.git
cd docs.nervos.org/examples/xudt
yarn && yarn start
```

----------------------------------------

TITLE: Configure Next.js dApp Network in .env (Bash)
DESCRIPTION: Modifies the NEXT_PUBLIC_NETWORK environment variable in the .env file to specify the desired CKB network for the Next.js dApp. Choose 'devnet', 'testnet', or 'mainnet'.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/blockchain-networks.mdx#_snippet_3

LANGUAGE: bash
CODE:
```
NEXT_PUBLIC_NETWORK=testnet # or testnet, mainnet
```

----------------------------------------

TITLE: Initializing CKB Dev Chain (Shell)
DESCRIPTION: This shell script sequence shows how to navigate to the project directory, set the CKB binary path, check the CKB version, initialize a new CKB dev chain configuration with a specific block assembler argument, and finally run the CKB node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_27

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ export CKB="<path to your ckb binary>"
$ $CKB --version
ckb 0.28.0 (728eff2 2020-02-04)
# Block assembler args configured here correspond to the following private key:
# 0x0a14c6fd7af6a3f13c9e2aacad80d78968de5d068a342828080650084bf20104
$ $CKB init -c dev -C ckb-data --ba-arg 0x5a7487f529b8b8fd4d4a57c12dc0c70f7958a196
$ $CKB run -C ckb-data
```

----------------------------------------

TITLE: Setup Project Directory - Lumos - Bash
DESCRIPTION: Creates a new directory named `lumos-example`, navigates into it, and initializes a new pnpm project with default settings (`-y`). This sets up the basic project structure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_1

LANGUAGE: Bash
CODE:
```
mkdir lumos-example
cd lumos-example
pnpm init -y
```

----------------------------------------

TITLE: Install OffCKB CLI - Bash
DESCRIPTION: Installs the OffCKB command-line interface globally using npm. OffCKB sets up a local CKB Devnet for testing dApps.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
npm install -g @offckb/cli
```

----------------------------------------

TITLE: Defining Duktape Type Script Object (JavaScript) - Different Args
DESCRIPTION: Creates a Lumos script object representing a Duktape type script with a different set of hexadecimal arguments generated from a different JavaScript source.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_20

LANGUAGE: JavaScript
CODE:
```
const duktapeTypeScript =  {
  codeHash: duktapeCodeHash,
  hashType: "data",
  args: "0x330000000c0000002f000000000000001b0000007661722061203d20313b5c6e7661722062203d2061202b20323b0a04000000"
};
```

----------------------------------------

TITLE: Start CKB Devnet using offckb
DESCRIPTION: Starts a local CKB development network node using the globally installed offckb CLI tool. This provides a local blockchain environment for testing.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-transfer/README.md#_snippet_3

LANGUAGE: Shell
CODE:
```
offckb node
```

----------------------------------------

TITLE: Deploying Duktape Binary on CKB using Lumos
DESCRIPTION: JavaScript code using the Lumos library to read the Duktape binary file, create a transaction to deploy it as a cell on CKB, sign the transaction, and send it to the RPC node. This makes the Duktape VM available as a script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_4

LANGUAGE: javascript
CODE:
```
const fs = require("fs");
const data = fs.readFileSync("../ckb-duktape/build/duktape");
data.byteLength;
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = await lumos.commons.common.transfer(txSkeleton, [wallet.address], wallet2.address, "292000" + "00000000");
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet.address], 1000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const duktapeTxHash = await rpc.sendTransaction(signedTx);
const duktapeCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
```

----------------------------------------

TITLE: Initializing CKB-SDK-Java Client
DESCRIPTION: Code snippet demonstrating how to import necessary classes and initialize the CKB RPC API client, connecting to a specified network URL (Testnet, Devnet, or Mainnet).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_4

LANGUAGE: Java
CODE:
```
import org.nervos.ckb.service.Api;
import org.nervos.ckb.service.CkbRpcApi;

String testnetUrl = "https://testnet.ckb.dev"; // Testnet
String devnetUrl = "http://127.0.0.1:8114"; // Devnet
String mainnetUrl = "https://mainnet.ckb.dev/rpc"; // Mainnet

// Connect to Testnet
CkbRpcApi ckbApi = new Api(testnetUrl);
```

----------------------------------------

TITLE: Setup CKB-SDK-Go Client (Go)
DESCRIPTION: Demonstrates how to import the necessary RPC package and establish a connection to a CKB node (Testnet, Devnet, or Mainnet) by providing the appropriate URL to the `rpc.Dial` function.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_4

LANGUAGE: Go
CODE:
```
import (
	"github.com/nervosnetwork/ckb-sdk-go/v2/rpc"
)

testnetURL := "https://testnet.ckb.dev" // Testnet
devnetURL := "http://127.0.0.1:8114" // Devnet
mainnetURL := "https://mainnet.ckb.dev/rpc" // Mainnet

// Connect to Testnet
ckbClient, err := rpc.Dial(testnetURL)
```

----------------------------------------

TITLE: Define Duktape Type Script Object (Variable JS) - JavaScript
DESCRIPTION: Creates a JavaScript object representing the CKB script for duktape. It includes the `codeHash` and `hashType`, and the `args` generated by `native_args_assembler` for the JavaScript code involving variable declarations.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_19

LANGUAGE: JavaScript
CODE:
```
const duktapeTypeScript =  {
  codeHash: duktapeCodeHash,
  hashType: "data",
  args: "0x330000000c0000002f000000000000001b0000007661722061203d20313b5c6e7661722062203d2061202b20323b0a04000000"
};
```

----------------------------------------

TITLE: Deploying ckb-js-vm Script (sh)
DESCRIPTION: Command and response for deploying the `ckb-js-vm` binary to the CKB devnet using `offckb deploy`. This makes the VM available as a script on-chain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_12

LANGUAGE: sh
CODE:
```
offckb deploy --target ./deps/ckb-js-vm --type-id
```

LANGUAGE: sh
CODE:
```
wait for tx confirmed on-chain...
tx committed.
ckb-js-vm deployment.toml file /Library/Application Support/offckb-nodejs/devnet/contracts/ckb-js-vm/deployment.toml generated successfully.
ckb-js-vm migration json file /Library/Application Support/offckb-nodejs/devnet/contracts/ckb-js-vm/migrations/2024-11-18-195031.json generated successfully.
done.
```

----------------------------------------

TITLE: Deploying Duktape and HTLC Script on CKB (JavaScript)
DESCRIPTION: This script deploys the Duktape VM binary and the HTLC JavaScript script onto the CKB blockchain as separate cells. It reads the binary and script files, calculates the required capacity for each, constructs a transaction with outputs containing the script data, signs the transaction using a provided private key, and sends it to a specified CKB node URL. The transaction hash is printed and saved to a file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_18

LANGUAGE: JavaScript
CODE:
```
#!/usr/bin/env node

const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

if (process.argv.length !== 6) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <js script> <private key> <node URL>`)
  process.exit(1)
}

const duktapeBinary = fs.readFileSync(process.argv[2])
const jsScript = fs.readFileSync(process.argv[3])

const privateKey = process.argv[4]
const nodeUrl = process.argv[5]

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const duktapeBinaryCapacity = BigInt(duktapeBinary.length) * 100000000n + 4100000000n
  const jsScriptCapacity = BigInt(jsScript.length) * 100000000n + 4100000000n

  const outputs = [
    {
      lock: {
        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
        hashType: 'data',
        args: '0x'
      },
      type: null,
      capacity: '0x' + duktapeBinaryCapacity.toString(16)
    },
    {
      lock: {
        codeHash: '0x0000000000000000000000000000000000000000000000000000000000000000',
        hashType: 'data',
        args: '0x'
      },
      type: null,
      capacity: '0x' + jsScriptCapacity.toString(16)
    },
    {
      lock: lockScript,
      type: null,
      capacity: '0x' + (totalCapacity - jsScriptCapacity - duktapeBinaryCapacity - fee).toString(16)
    }
  ]
  const outputsData = [
    utils.bytesToHex(duktapeBinary),
    utils.bytesToHex(jsScript),
    '0x'
  ]

  const transaction = {
    version: '0x0',
    cellDeps: [
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs,
    witnesses: [
      {
        lock: '',
        inputType: '',
        outputType: ''
      }
    ],
    outputsData
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)

  const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

  console.log(`Transaction hash: ${txHash}`)
  fs.writeFileSync('deploy_scripts_result.txt', txHash)
}

run()
```

----------------------------------------

TITLE: Deploying Smart Contracts to Testnet with offckb (Shell)
DESCRIPTION: Navigates into the frontend project directory and executes the `offckb deploy` command specifically targeting the CKB Testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-lock/README.md#_snippet_2

LANGUAGE: sh
CODE:
```
cd frontend
offckb deploy --network testnet
```

----------------------------------------

TITLE: Generating Code with moleculec (Bash)
DESCRIPTION: Generates code from a Molecule schema file using the `moleculec` tool. Requires specifying the target programming language and the path to the schema file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/tools.mdx#_snippet_1

LANGUAGE: bash
CODE:
```
moleculec --language <language> --schema-file <schema-file>
```

----------------------------------------

TITLE: Deploying Duktape Script on CKB
DESCRIPTION: This JavaScript snippet demonstrates how to read the compiled Duktape RISC-V binary file from the filesystem, check its size, and prepare a CKB transaction using the Lumos library to transfer the binary data into a cell on the blockchain, making it available as a script code.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_14

LANGUAGE: javascript
CODE:
```
> const data = fs.readFileSync("../ckb-duktape/build/duktape");
> data.byteLength
291440
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"292000" + "00000000");
```

----------------------------------------

TITLE: Install CKB-Debugger (≥0.113.0)
DESCRIPTION: Install CKB-Debugger, a CLI tool for off-chain CKB Script development and testing. Version ≥0.113.0 is recommended.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_17

LANGUAGE: bash
CODE:
```
cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger
```

----------------------------------------

TITLE: Install offckb CLI Tool
DESCRIPTION: Installs the offckb command-line interface tool globally using npm. This tool is used to start and manage a local CKB development network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-transfer/README.md#_snippet_2

LANGUAGE: Shell
CODE:
```
npm install -g offckb
```

----------------------------------------

TITLE: Compile C code to RISC-V using Docker (Shell)
DESCRIPTION: Commands executed within a Docker container providing the CKB RISC-V GNU toolchain. This sequence compiles the C source files (main.c, fib.c, wasm-rt-impl.c) into a RISC-V executable named fib_riscv64.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-4.md#_snippet_9

LANGUAGE: Shell
CODE:
```
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:xenial bash
(docker) $ cd /code
(docker) $ riscv64-unknown-elf-gcc -o fib_riscv64 -O3 -g main.c fib.c /code/wabt/wasm2c/wasm-rt-impl.c -I /code/wabt/wasm2c
(docker) $ exit
```

----------------------------------------

TITLE: Summing Output UDT Amounts and Validating Transfer in CKB Script (JavaScript)
DESCRIPTION: Iterates through all output cells belonging to the current script group, loads the first 4 bytes (UDT amount) from each, calculates the total sum, and compares it to the previously calculated sum of input UDTs. Throws an error if the sums do not match, enforcing the transfer rule.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_1

LANGUAGE: JavaScript
CODE:
```
var output_index = 0;
var output_coins = 0;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, output_index, CKB.SOURCE.GROUP_OUTPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid output cell!";
  }
  var view = new DataView(buffer);
  output_coins += view.getUint32(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  throw "Input coins do not equal output coins!";
}
```

----------------------------------------

TITLE: Install Rustup - Linux - Bash
DESCRIPTION: Installs the Rust toolchain manager (rustup) on Linux using the official rustup script. Rust is needed for CKB script development.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_10

LANGUAGE: bash
CODE:
```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

----------------------------------------

TITLE: Implement and Test CKB Blake2b Hash (Python)
DESCRIPTION: This Python code provides an implementation of the CKB default Blake2b hash function, configured with a 32-byte digest size and 'ckb-default-hash' personalization. It includes a unit test to verify the hash output for an empty input message.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/glossary.md#_snippet_5

LANGUAGE: Python
CODE:
```
import hashlib
import unittest

def ckbhash():
    return hashlib.blake2b(digest_size=32, person=b'ckb-default-hash')

class TestCKBBlake2b(unittest.TestCase):

    def test_empty_message(self):
        hasher = ckbhash()
        hasher.update(b'')
        self.assertEqual('44f4c69744d5f8c55d642062949dcae49bc4e7ef43d388c5a12f42b5633d163e', hasher.hexdigest())

if __name__ == '__main__':
    unittest.main()
```

----------------------------------------

TITLE: Define Custom Token Output Cell - TypeScript
DESCRIPTION: Defines the structure of the output cell for the custom token within a transaction. It includes the issuer's lock script, the xUDT type script, and the token amount encoded in the outputsData field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_2

LANGUAGE: ts
CODE:
```
const tx = ccc.Transaction.from({
  outputs: [{ lock: lockScript, type: typeScript }],
  outputsData: [ccc.numLeToBytes(amount, 16)],
});
```

----------------------------------------

TITLE: Unlocking HTLC Cell via Secret String (JavaScript)
DESCRIPTION: This script outlines the process for unlocking an HTLC-protected cell on the CKB network using a secret string. It parses command-line arguments for transaction hashes, private key, node URL, and the secret. It calculates the lock hash, loads user cells, and begins constructing the unlock transaction, including the serialization of the HTLC witness data using a Molecule schema.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_23

LANGUAGE: JavaScript
CODE:
```
$ cd $TOP/htlc-runner
$ cat unlock_via_secret_string.js
#!/usr/bin/env node

const { Molecule } = require('molecule-javascript')
const crc32 = require('crc32')
const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 8) {
  console.log(`Usage: ${process.argv[1]} <deployed tx hash> <htlc cell tx hash> <private key> <node URL> <secret string> <dry run>`)
  process.exit(1)
}

const deployedTxHash = process.argv[2]
const htlcCellTxHash = process.argv[3]
const privateKey = process.argv[4]
const nodeUrl = process.argv[5]
const secretString = process.argv[6]
const dryrun = process.argv[7] === 'true'

function stringToHexStringArray(s) {
  let a = []
  for (let i = 0; i < s.length; i++) {
    a.push('0x' + ('00' + s.charCodeAt(i).toString(16)).slice(-2))
  }
  return a
}

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const htlcCellCapacity = 200000000000n

  const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
  const htlcWitnessType = new Molecule(
    customSchema.declarations.find(d => d.name == "HtlcWitness"))
  const htlcWitness = htlcWitnessType.serialize([

```

----------------------------------------

TITLE: Start CKB Devnet with Default Version
DESCRIPTION: Starts a local CKB development network node using the default CKB version configured for OffCKB. The RPC server will be available at http://localhost:8114.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_3

LANGUAGE: bash
CODE:
```
offckb node
```

----------------------------------------

TITLE: Start CKB Devnet with offckb
DESCRIPTION: Executes the 'offckb node' command to start a local CKB development network instance, which is useful for testing Dapps locally without connecting to a public network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/create-dob/README.md#_snippet_3

LANGUAGE: Shell
CODE:
```
offckb node
```

----------------------------------------

TITLE: Illustrating Pipe Creation and Reading (Rust)
DESCRIPTION: Illustrates the creation of pipes for inter-process communication and how the parent process reads data from one of the pipes. Two pipes are created to allow data flow in both directions between the caller and callee scripts.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_10

LANGUAGE: Rust
CODE:
```
let (r1, w1) = ckb_std::syscalls::pipe()?;
let (r2, w2) = ckb_std::syscalls::pipe()?;
let to_parent_fds: [u64; 2] = [r1, w2];
let to_child_fds: [u64; 3] = [r2, w1, 0]; // must ends with 0


// ...

let len = ckb_std::syscalls::read(to_parent_fds[0], &mut buf)?;
```

----------------------------------------

TITLE: Converting Raw Transaction JSON with ckb-transaction-dumper (Bash)
DESCRIPTION: Uses the `ckb-transaction-dumper` tool to process a raw transaction JSON file (`failed-tx.json`) and generate a more detailed dump (`full-failed-tx.json`), requiring a CKB RPC URL.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_8

LANGUAGE: Bash
CODE:
```
ckb-transaction-dumper -t failed-tx.json -o full-failed-tx.json -r <mainnet/testnet/devnet RPC url>
```

----------------------------------------

TITLE: Rendering Spore Content as Image (TypeScript/JSX)
DESCRIPTION: This asynchronous function fetches the raw spore data using `showSporeContent`, converts the hexadecimal content into a binary buffer, creates a Blob with the appropriate content type, generates a temporary URL for the Blob, and updates a state variable to display the image using an `<img>` tag.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-dob.mdx#_snippet_7

LANGUAGE: TypeScript
CODE:
```
const renderSpore = async () => {
  const res = await showSporeContent(txHash, outputIndex);
  if (!res) return;
  setRawSporeData(res);

  // Create Blob from binary data
  const buffer = hexStringToUint8Array(res.content.toString().slice(2));
  const blob = new Blob([buffer], { type: res.contentType });
  const url = URL.createObjectURL(blob);
  setImageURL(url);
};

...
{imageURL && <img src={imageURL} />}
```

----------------------------------------

TITLE: Transfer Spore Token using CKB CCC (TypeScript)
DESCRIPTION: This snippet demonstrates how to transfer a Spore token to a recipient address using the @ckb-ccc/ccc library. It includes steps for determining the receiver, specifying the Spore ID, building the transfer transaction, completing the transaction fee, sending the transaction, and waiting for confirmation. Requires @ckb-ccc/ccc and @ckb-ccc/playground.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_18

LANGUAGE: TypeScript
CODE:
```
import { ccc } from "@ckb-ccc/ccc";
import { render, signer } from "@ckb-ccc/playground";

function getExplorerTxUrl(txHash: string) {
  const isMainnet = signer.client.addressPrefix === "ckb";
  const baseUrl = isMainnet
    ? "https://explorer.nervos.org"
    : "https://testnet.explorer.nervos.org";

  return `${baseUrl}/transaction/${txHash}`;
}

// The receiver is the signer itself on mainnet
const receiver =
  signer.client.addressPrefix === "ckb"
    ? await signer.getRecommendedAddress()
    : "ckt1qrfrwcdnvssswdwpn3s9v8fp87emat306ctjwsm3nmlkjg8qyza2cqgqq8tfmtd3hl2gj0haq54t24kgwtdpz5ffzukkny82";
console.log(receiver);

const { script: to } = await ccc.Address.fromString(receiver, signer.client);

// Replace with your spore id
const sporeId =
  "0x39b78c12f632742d53fb009a4c9b25fbcf8ea0891fea1a180eeac97299ab158f";

// Build transaction
const { tx } = await ccc.spore.transferSpore({
  signer,
  id: sporeId,
  to,
});
await render(tx);

// Complete missing parts: Pay fee
await tx.completeFeeBy(signer, 1000);
await render(tx);

// Send transaction
const txHash = await signer.sendTransaction(tx);
console.log("Transaction sent:", getExplorerTxUrl(txHash));
await signer.client.waitTransaction(txHash);
// https://testnet.explorer.nervos.org/transaction/0x8ab5a1e5d6bec881b4535ae02b0c39f7adabb1970dffb18e7b5aa16f9a89a289
console.log("Transaction committed:", getExplorerTxUrl(txHash));
await render(tx);
```

----------------------------------------

TITLE: Serialize Multiple Uint32s in Uint32Vec Fixvec
DESCRIPTION: Illustrates the serialization of a fixed vector containing multiple Uint32 values. The serialized form includes the 4-byte length prefix (6) followed by the serialized items (each Uint32 in little-endian).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/encoding-specs.mdx#_snippet_10

LANGUAGE: Hex Bytes
CODE:
```
06 00 00 00\n23 01 00 00, 56 04 00 00, 90 78 00 00, 0a 00 00 00, bc 00 00 00, ef 0d 00 00
```

----------------------------------------

TITLE: Updating CKB Transaction Output Data (JavaScript)
DESCRIPTION: Updates the data field of the first output cell in a Lumos transaction skeleton with a hexadecimal representation of the provided data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_15

LANGUAGE: JavaScript
CODE:
```
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
```

----------------------------------------

TITLE: Implement CKB Contract Callee Logic in Rust
DESCRIPTION: Provides the main entry point `program_entry` and the core `callee` function for a CKB contract. The `callee` function retrieves arguments, inherits file descriptors (pipes), concatenates arguments, and writes the result to the parent process via a pipe using the `write` syscall.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_12

LANGUAGE: Rust
CODE:
```
mod error;
use alloc::vec;

pub fn program_entry() -> i8 {
    ckb_std::debug!("Enter callee contract!");

    match callee() {
        Ok(_) => 0,
        Err(err) => err as i8,
    }
}

pub fn callee() -> Result<(), error::Error> {
    let argv = ckb_std::env::argv();
    let mut to_parent_fds: [u64; 2] = [0; 2];
    ckb_std::syscalls::inherited_fds(&mut to_parent_fds);
    let mut out = vec![];
    for arg in argv {
        out.extend_from_slice(arg.to_bytes());
    }
    let len = ckb_std::syscalls::write(to_parent_fds[1], &out)?;
    assert_eq!(len, 10);
    Ok(())
}
```

----------------------------------------

TITLE: Starting CKB Dev Chain (Shell)
DESCRIPTION: This shell script snippet sets up the environment and starts a CKB development chain instance. It navigates directories, exports the CKB binary path, checks the version, initializes a dev chain data directory, and runs the CKB node.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_27

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ export CKB="<path to your ckb binary>"
$ $CKB --version
ckb 0.28.0 (728eff2 2020-02-04)
# Block assembler args configured here correspond to the following private key:
# 0x0a14c6fd7af6a3f13c9e2aacad80d78968de5d068a342828080650084bf20104
$ $CKB init -c dev -C ckb-data --ba-arg 0x5a7487f529b8b8fd4d4a57c12dc0c70f7958a196
$ $CKB run -C ckb-data
```

----------------------------------------

TITLE: Deploying ckb-duktape REPL Binary using Lumos
DESCRIPTION: This JavaScript snippet, intended for a Node.js environment using the Lumos library, demonstrates how to read the compiled ckb-duktape REPL binary, create a CKB transaction to deploy it as cell data, sign the transaction, and send it to the CKB testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_10

LANGUAGE: javascript
CODE:
```
$ node
Welcome to Node.js v20.12.0.
Type ".help" for more information.
>
> const lumos = require("@ckb-lumos/lumos");
> const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
> const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
> lumos.config.initializeConfig(lumos.config.TESTNET);
> const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6",
};
> const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}

> const data = fs.readFileSync("./ckb-duktape/build/repl");
> data.byteLength
306040
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"306240" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const duktapeReplTxHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Start CKB Light Client Node (Bash)
DESCRIPTION: Bash command to execute the CKB light client binary, specifying the logging level for Rust and the path to the configuration file (`mainnet.toml`) to start the node process.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/run-light-client-node.mdx#_snippet_3

LANGUAGE: bash
CODE:
```
RUST_LOG=info,ckb_light_client=info ./ckb-light-client run --config-file ./mainnet.toml
```

----------------------------------------

TITLE: WABT C Wrapper for CKB - C
DESCRIPTION: This C code provides a wrapper for the WASM-to-C output generated by WABT. It includes necessary headers for CKB syscalls, defines an `env_abort` function, loads input data from the CKB witness, initializes the WASM module, calls the exported `fib` function, and returns the result.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_3

LANGUAGE: C
CODE:
```
#include <stdio.h>
#include <stdlib.h>
#include "ckb_syscalls.h"

#include "fib.h"

void (*Z_envZ_abortZ_viiii)(u32, u32, u32, u32);

void env_abort(u32 a, u32 b, u32 c, u32 d) {
  abort();
}

int main() {
  uint32_t value;
  uint64_t len = 4;
  int ret = ckb_load_witness((void*) &value, &len, 0, 0,
                             CKB_SOURCE_GROUP_INPUT);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (len < 4) {
    return -1;
  }

  init();
  u8 result = Z_fibZ_ii(value);

  return result;
}
```

----------------------------------------

TITLE: Create CKB Script Object from Data Hash (JavaScript)
DESCRIPTION: Shows how to create a CKB script object (`carrotTypeScript`) in Lumos. It calculates the Blake2b hash of the deployed script data (`carrot`) using `lumos.utils.ckbHash`, sets the `hashType` to "data", and uses an empty string for `args` as the script doesn't require arguments. This object represents the script that can be referenced in a cell's `type` or `lock` script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_6

LANGUAGE: js
CODE:
```
> const bytes = require("@ckb-lumos/lumos/codec").bytes;
> const carrotDataHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
> const carrotTypeScript =  {
  codeHash: carrotDataHash,
  hashType: "data",
  args: "0x"
};
```

----------------------------------------

TITLE: Configure lib.rs for Native Simulator (Rust)
DESCRIPTION: Sets up the `lib.rs` file to conditionally disable `no_std` when the `native-simulator` feature is enabled. It also conditionally includes and exports the `program_entry` function from a `main` module, allowing the simulator to call the script's entry point.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_19

LANGUAGE: Rust
CODE:
```
#![cfg_attr(not(feature = "native-simulator"), no_std)]
#![allow(special_module_name)]
#![allow(unused_attributes)]
#[cfg(feature = "native-simulator")]
mod main;
#[cfg(feature = "native-simulator")]
pub use main::program_entry;
```

----------------------------------------

TITLE: Serializing HTLC Arguments with Molecule (JavaScript)
DESCRIPTION: This snippet demonstrates how to use the Molecule library to serialize the arguments for an HTLC script. It reads a custom Molecule schema from a JSON file, finds the definition for "HtlcArgs", and then serializes an array of key-value pairs representing the HTLC arguments (lock hashes 'a' and 'b', and the hash of the secret) into a byte string format suitable for use in a CKB script's `args` field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_22

LANGUAGE: JavaScript
CODE:
```
const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
const htlcArgsType = new Molecule(
  customSchema.declarations.find(d => d.name == "HtlcArgs"))
const htlcScriptArgs = htlcArgsType.serialize([
  ['a', hexStringToHexStringArray(lockHashA)],
  ['b', hexStringToHexStringArray(lockHashB)],
  ['hash', hexStringToHexStringArray('0x' + crc32('i am a secret'))]
])
```

----------------------------------------

TITLE: Defining Duktape Type Script Object (JavaScript)
DESCRIPTION: Creates a Lumos script object representing a Duktape type script, using the calculated `codeHash` and the hexadecimal arguments generated by `native_args_assembler`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_18

LANGUAGE: JavaScript
CODE:
```
const duktapeTypeScript =  {
  codeHash: duktapeCodeHash,
  hashType: "data",
  args: "0x370000000c00000033000000000000001f000000434b422e6465627567282249276d2072756e6e696e6720696e204a5322290a04000000"
};
```

----------------------------------------

TITLE: Defining Duktape UDT Script Configuration Object - JavaScript
DESCRIPTION: This JavaScript snippet defines a configuration object used to reference a Duktape script on the CKB blockchain. It specifies the `codeHash` of the script and the `hashType` as 'data', which are essential parameters for including the script in a CKB transaction.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_7

LANGUAGE: javascript
CODE:
```
let duktapeUdtTypeScript = {
    codeHash: duktapeCodeHash,
    hashType: "data",
}
```

----------------------------------------

TITLE: offckb Inject Config Response
DESCRIPTION: Shows the output after running `offckb inject-config`, confirming that the configuration was successfully injected. It also provides examples of how to import and use the generated `offckb.config` object to access script code hashes within the project.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_17

LANGUAGE: bash
CODE:
```
All good. You can now use it in your project like:

  import offCKB from "offckb.config";

  const myScriptCodeHash = offCKB.myScripts['script-name'].codeHash;
  const omnilockScriptCodeHash = offCKB.systemScripts['omnilock'].codeHash;

Check example at https://github.com/nervosnetwork/docs.nervos.org/tree/develop/examples/simple-transfer
```

----------------------------------------

TITLE: Loading Witness with ckb_load_witness (C)
DESCRIPTION: Example of the CKB syscall `ckb_load_witness` used to load a witness from the transaction. The example shows loading the first witness (index 0) from the transaction inputs using `CKB_SOURCE_INPUT`. Parameters `addr`, `len`, and `offset` control data storage and length.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/script-group-exe.mdx#_snippet_1

LANGUAGE: C
CODE:
```
ckb_load_witness(addr, len, offset, 0, CKB_SOURCE_INPUT);
```

----------------------------------------

TITLE: Implement Service Logic and Start Server (Rust)
DESCRIPTION: Implement the defined service trait (`World`) for your server struct (`WorldServer`). The `run_server` function starts the server, entering an infinite loop to handle incoming client requests. The `server()` method is automatically generated by the procedural macro.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/ckb-script-ipc.mdx#_snippet_3

LANGUAGE: Rust
CODE:
```
use crate::def::World;
use ckb_script_ipc_common::spawn::run_server;

struct WorldServer;

impl World for WorldServer {
    fn hello(&mut self, name: String) -> Result<String, u64> {
        if name == "error" {
            Err(1)
        } else {
            Ok(format!("hello, {}", name))
        }
    }
}

run_server(WorldServer.server()).map_err(|_| Error::ServerError)
```

----------------------------------------

TITLE: Summing Input UDTs (JavaScript)
DESCRIPTION: Iterates through all input cells within the current script group using `CKB.raw_load_cell_data`. It reads the first 4 bytes (UDT amount) from each cell's data, sums them up, and stores the total in `input_coins`. Requires the CKB JavaScript environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_0

LANGUAGE: JavaScript
CODE:
```
var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var ret = CKB.CODE.INDEX_OUT_OF_BOUND;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, input_index, CKB.SOURCE.GROUP_INPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid input cell!";
  }
  var view = new DataView(buffer);
  input_coins += view.getUint32(0, true);
  input_index += 1;
}
```

----------------------------------------

TITLE: Start CKB Testnet Node
DESCRIPTION: Execute the command to start the CKB node and begin syncing with the Pudge Testnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/run-testnet-node.mdx#_snippet_5

LANGUAGE: bash
CODE:
```
ckb run
```

----------------------------------------

TITLE: Parse CKB Address String (Java)
DESCRIPTION: Demonstrates how to decode an encoded CKB address string using `Address.decode()`, retrieving the associated `Script`, `Network`, and re-encoding the address.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_10

LANGUAGE: Java
CODE:
```
Address address = Address.decode("ckt1qyqxgp7za7dajm5wzjkye52asc8fxvvqy9eqlhp82g");
Script script = address.getScript();
Network network = address.getNetwork();
System.out.println(address.encode());
```

----------------------------------------

TITLE: Start OffCKB REPL - OffCKB CLI
DESCRIPTION: Launch the OffCKB interactive Node.js REPL environment. This REPL includes built-in CKB-related variables and functions, making it suitable for simple script testing and development tasks directly in the terminal.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_28

LANGUAGE: bash
CODE:
```
offckb repl --network <devnet/testnet/mainnet, default: devnet>
```

----------------------------------------

TITLE: Starting offckb Nodejs REPL (sh)
DESCRIPTION: Command and initial output for starting the `offckb` Node.js REPL, which provides an interactive environment for building and sending transactions using the CCC SDK.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_14

LANGUAGE: sh
CODE:
```
offckb repl -r
```

LANGUAGE: sh
CODE:
```
Welcome to OffCKB REPL!
[[ Default Network: devnet, enableProxyRPC: true, CCC SDK: 0.0.16-alpha.3 ]]
Type 'help()' to learn how to use.
OffCKB >
```

----------------------------------------

TITLE: Install offckb CLI Tool
DESCRIPTION: Installs the 'offckb' command-line interface tool globally using npm. This tool is required to start and manage a local CKB development network (devnet).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/store-data-on-cell/README.md#_snippet_2

LANGUAGE: sh
CODE:
```
npm install -g offckb
```

----------------------------------------

TITLE: Defining CKB Script Structure in Rust
DESCRIPTION: This snippet shows the Rust definition for the `Script` data structure in CKB. It includes fields for `code_hash` (identifying the script code), `hash_type` (for future explanation), and `args` (for providing additional arguments like pubkey hashes). This structure represents a specific instance of a script, distinct from the underlying script code.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_0

LANGUAGE: Rust
CODE:
```
pub struct Script {
    pub code_hash: H256,
    pub hash_type: ScriptHashType,
    pub args: JsonBytes,
}
```

----------------------------------------

TITLE: Restart OffCKB Devnet Node
DESCRIPTION: Run this command to start or restart the OffCKB devnet node. It will load the configurations from the specified config path and use the data path for chain storage.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_13

LANGUAGE: bash
CODE:
```
offckb node
```

----------------------------------------

TITLE: Create Spore DOB using Spore SDK (JavaScript)
DESCRIPTION: Shows how to create a Spore DOB with `content_type` 'dob/0' using the `@spore-sdk/api` library, including setting content and linking to a cluster.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/spore-dob-0.mdx#_snippet_5

LANGUAGE: JavaScript
CODE:
```
import { createSpore } from '@spore-sdk/api';
import { bytifyRawString } from '@spore-sdk/helpers/buffer';

const account = ...;
const dob_cluster_id = ...;
const dob_content = {
  dna: 'df4ffcb5e7a283ea7e6f09a504d0e256'
};

const { txSkeleton, outputIndex } = await createSpore({
  data: {
    contentType: 'dob/0',
    content: bytifyRawString(JSON.strinify(dob_content)),
    clusterId: dob_cluster_id
  },
  fromInfos: [account.address],
  toLock: account.lock
});
```

----------------------------------------

TITLE: Sign and Verify Message with CCC Signer (React)
DESCRIPTION: React component demonstrating how to use a CCC signer to sign a user-provided message and then verify the signature using `ccc.Signer.verifyMessage`. Requires a connected signer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_7

LANGUAGE: tsx
CODE:
```
"use client";

import { ccc } from "@ckb-ccc/connector-react";
import React, { useState } from "react";
import { Button } from "@/src/components/Button";
import { TextInput } from "@/src/components/Input";
import { useApp } from "@/src/context";
import { ButtonsPanel } from "@/src/components/ButtonsPanel";

export default function Sign() {
  const { signer, createSender } = useApp();
  const { log, error } = createSender("Sign");

  const [messageToSign, setMessageToSign] = useState<string>("");
  const [signature, setSignature] = useState<string>("");
  return (
    <div className="flex w-full flex-col items-stretch">
      <TextInput
        label="Message"
        placeholder="Message to sign and verify"
        state={[messageToSign, setMessageToSign]}
      />
      <ButtonsPanel>
        <Button
          onClick={async () => {
            if (!signer) {
              return;
            }
            const sig = JSON.stringify(await signer.signMessage(messageToSign));
            setSignature(sig);
            log("Signature:", sig);
          }}
        >
          Sign
        </Button>
        <Button
          className="ml-2"
          onClick={async () => {
            if (
              !(await ccc.Signer.verifyMessage(
                messageToSign,
                JSON.parse(signature)
              ))
            ) {
              error("Invalid");
              return;
            }
            log("Valid");
          }}
        >
          Verify
        </Button>
      </ButtonsPanel>
    </div>
  );
}
```

----------------------------------------

TITLE: Configure main.rs for Native Simulator (Rust)
DESCRIPTION: Modifies the `main.rs` file to conditionally apply `no_std` and `no_main` attributes, include the `alloc` crate, and use the `ckb_std::entry!` macro and `ckb_std::default_alloc!` macro only when the `native-simulator` or `test` features are *not* enabled. This allows the same code to compile for both RISC-V (no_std, no_main) and native simulation (standard main function).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_21

LANGUAGE: Rust
CODE:
```
#![cfg_attr(not(any(feature = "native-simulator", test)), no_std)]
#![cfg_attr(not(test), no_main)]

#[cfg(any(feature = "native-simulator", test))]
extern crate alloc;

#[cfg(not(any(feature = "native-simulator", test)))]
ckb_std::entry!(program_entry);
#[cfg(not(any(feature = "native-simulator", test)))]
ckb_std::default_alloc!();

pub fn program_entry() -> i8 {
    ...
    0
}
```

----------------------------------------

TITLE: Install CKB-CLI using Cargo
DESCRIPTION: Provides the steps to clone the ckb-cli repository from GitHub and install the tool using Rust's package manager, Cargo.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ckb-cli.mdx#_snippet_0

LANGUAGE: Shell
CODE:
```
git clone https://github.com/nervosnetwork/ckb-cli.git
cd ckb-cli
cargo install --path . -f --locked
```

----------------------------------------

TITLE: Start CKB Devnet using offckb
DESCRIPTION: Starts a local CKB development network node using the installed 'offckb' CLI tool. This command initiates a local blockchain environment for testing the Dapp.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/store-data-on-cell/README.md#_snippet_3

LANGUAGE: sh
CODE:
```
offckb node
```

----------------------------------------

TITLE: Unlock HTLC via Secret String (Invalid Public Key) - Shell
DESCRIPTION: Shows attempting to unlock an HTLC cell using the `unlock_via_secret_string.js` script with the correct secret but an invalid public key. This scenario is also expected to result in a validation failure.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_31

LANGUAGE: Shell
CODE:
```
./unlock_via_secret_string.js \
    0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e008d636b8c9154f5c296e1f4 \
    0x7de8ea6b0d6cb9941e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd \
    0x63d86723e08f0f813a36ce6aa123bb2289d90680ae1e99d4de8cdb334553f24d \
    "http://127.0.0.1:8114/" \
    "i am a secret" \
    true
```

----------------------------------------

TITLE: Summing Input UDT Amounts in CKB Script (JavaScript)
DESCRIPTION: Iterates through all input cells belonging to the current script group, loads the first 4 bytes (representing the UDT amount) from each cell's data, and calculates the total sum of UDTs in the inputs. Uses `CKB.raw_load_cell_data` to access cell data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_0

LANGUAGE: JavaScript
CODE:
```
var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var ret = CKB.CODE.INDEX_OUT_OF_BOUND;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, input_index, CKB.SOURCE.GROUP_INPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid input cell!";
  }
  var view = new DataView(buffer);
  input_coins += view.getUint32(0, true);
  input_index += 1;
}
```

----------------------------------------

TITLE: Download On-Chain Transaction with ckb-cli
DESCRIPTION: Uses the `ckb-cli` tool to download a specific transaction from the CKB mainnet RPC and save it as a JSON file for local debugging.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_3

LANGUAGE: sh
CODE:
```
$ ckb-cli --url https://mainnet.ckbapp.dev/rpc mock-tx dump --tx-hash 0x5f0a4162622daa0e50b2cf8f49bc6ece22d1458d96fc12a094d6f074d6adbb55 --output-file mock_tx.json
```

----------------------------------------

TITLE: Create Spore with @ckb-ccc/ccc (TSX)
DESCRIPTION: Shows how to mint a Spore linked to a DOB Cluster using `@ckb-ccc/ccc`. It includes generating simple DNA content, calling `createSpore` with the cluster ID, handling transaction fee completion, sending the transaction, and waiting for confirmation. Requires `@ckb-ccc/ccc`, a signer/client setup, and a valid cluster ID.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_17

LANGUAGE: tsx
CODE:
```
import { ccc } from "@ckb-ccc/ccc";
import { client, signer } from "@ckb-ccc/playground";

function getExplorerTxUrl(txHash: string) {
  const isMainnet = client.addressPrefix === "ckb";
  const baseUrl = isMainnet
    ? "https://explorer.nervos.org"
    : "https://testnet.explorer.nervos.org";

  return `${baseUrl}/transaction/${txHash}`;
}

function generateSimpleDNA(length: number): string {
  return Array.from({ length }, () =>
    Math.floor(Math.random() * 16).toString(16)
  ).join("");
}

// TODO: Replace with your cluster ID
const clusterId = "{your cluster id}";

/**
 * create spore
 */
const { tx: sporeTx, id: sporeId } = await ccc.spore.createSpore({
  signer,
  data: {
    contentType: "dob/0",
    content: ccc.bytesFrom(`{ "dna": "${generateSimpleDNA(16)}" }`, "utf8"),
    clusterId: clusterId,
  },
  clusterMode: "clusterCell",
});

await sporeTx.completeFeeBy(signer, 2000n);
const sporeTxHash = await signer.sendTransaction(sporeTx);
console.log("Mint DOB tx sent:", sporeTxHash, `Spore ID: ${sporeId}`);
await signer.client.waitTransaction(sporeTxHash);
console.log(
  "Mint DOB tx committed:",
  getExplorerTxUrl(sporeTxHash),
  `Spore ID: ${sporeId}`
);
```

----------------------------------------

TITLE: CKB-VM Syscall Return Codes (C)
DESCRIPTION: These constants represent the possible return values from CKB-VM syscalls, indicating the outcome of the operation, such as success or various error conditions like out-of-bounds index, missing items, insufficient buffer length, invalid data, or file descriptor issues.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/syscalls-for-script.mdx#_snippet_0

LANGUAGE: C
CODE:
```
CKB_SUCCESS
```

LANGUAGE: C
CODE:
```
CKB_INDEX_OUT_OF_BOUND
```

LANGUAGE: C
CODE:
```
CKB_ITEM_MISSING
```

LANGUAGE: C
CODE:
```
CKB_LENGTH_NOT_ENOUGH
```

LANGUAGE: C
CODE:
```
CKB_INVALID_DATA
```

LANGUAGE: C
CODE:
```
CKB_WAIT_FAILURE
```

LANGUAGE: C
CODE:
```
CKB_INVALID_FD
```

LANGUAGE: C
CODE:
```
CKB_OTHER_END_CLOSED
```

LANGUAGE: C
CODE:
```
CKB_MAX_VMS_SPAWNED
```

LANGUAGE: C
CODE:
```
CKB_MAX_FDS_CREATED
```

----------------------------------------

TITLE: Run CKB Script with Duktape REPL (Shell)
DESCRIPTION: Similar to running the debugger, this command navigates to the `htlc-runner` directory and executes the runner script. However, it uses the `repl0` duktape binary instead of `load0`, which causes the script execution to drop into a Duktape REPL after processing the transaction setup.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_9

LANGUAGE: Shell
CODE:
```
$ cd $TOP/htlc-runner
$ RUST_LOG=debug `./runner.js ../ckb-duktape/build/repl0 ../htlc-template/build/duktape.js`
```

----------------------------------------

TITLE: Retrieving Spore Cell Data (TypeScript)
DESCRIPTION: This function retrieves a specific Spore Cell from the CKB blockchain using its transaction hash and output index. It fetches the live cell data and then unpacks the raw spore data from the cell's output.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-dob.mdx#_snippet_5

LANGUAGE: TypeScript
CODE:
```
export async function showSporeContent(txHash: string, index = 0) {
  const indexHex = "0x" + index.toString(16);
  const cell = await cccClient.getCellLive({ txHash, index: indexHex }, true);
  if (cell == null) {
    return alert("cell not found, please retry later");
  }
  const sporeData = unpackToRawSporeData(cell.outputData);
  console.log("spore data: ", sporeData);
  return sporeData;
}
```

----------------------------------------

TITLE: Start Devnet and Stop Instruction
DESCRIPTION: Initiates the local CKB development network node. The accompanying comment provides instructions on how to stop the running node process, typically by pressing Ctrl+C in the terminal where it's running.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_8

LANGUAGE: bash
CODE:
```
offckb node
# Once started, press Ctrl+C to stop the node
```

----------------------------------------

TITLE: Defining Vector Type in Molecule Schema Language (C Syntax)
DESCRIPTION: Demonstrates the syntax for defining a vector type in Molecule Schema Language. A vector is a composite type containing a variable-length sequence of items, all of the same type (ItemType).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/schema-language.mdx#_snippet_4

LANGUAGE: c
CODE:
```
vector VectorName <ItemType>;
```

----------------------------------------

TITLE: Native C Fibonacci Implementation for CKB - C
DESCRIPTION: This C code provides a native implementation of the Fibonacci function and a `main` function for the CKB environment. It includes the `ckb_syscalls.h` header, implements the `fib` function directly in C, loads input data from the CKB witness, calls the native `fib` function, and returns the result.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_5

LANGUAGE: C
CODE:
```
#include "ckb_syscalls.h"

int32_t fib(int32_t n) {
  int32_t a = 0;
  int32_t b = 1;

  for (int32_t i = 0; i < n; i++) {
    int32_t t = a + b;
    a = b;
    b = t;
  }

  return b;
}

int main() {
  uint32_t value;
  uint64_t len = 4;
  int ret = ckb_load_witness((void*) &value, &len, 0, 0,
                             CKB_SOURCE_GROUP_INPUT);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (len < 4) {
    return -1;
  }

  return fib(value);
}
```

----------------------------------------

TITLE: Defining Union Type in Molecule Schema Language (C Syntax)
DESCRIPTION: Presents the syntax for defining a union type in Molecule Schema Language. A union is a composite type that can hold a value of one of several specified types (ItemType1, ItemType2, etc.) at any given time.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/schema-language.mdx#_snippet_7

LANGUAGE: c
CODE:
```
union UnionName {
    ItemType1,
    ItemType2,
    ItemType3,
}
```

----------------------------------------

TITLE: Encode and Decode AttrValue - JavaScript
DESCRIPTION: Demonstrates the usage of the `AttrValueCodec` to serialize a valid `AttrValue` (80) into bytes and deserialize bytes ("50" hex) back into an `AttrValue`. This showcases the basic encode/decode functionality of the defined codec.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/ccc-molecule.mdx#_snippet_5

LANGUAGE: javascript
CODE:
```
AttrValueCodec.encode(80).toString();
AttrValueCodec.decode(Buffer.from("50", "hex")).toString();
```

----------------------------------------

TITLE: Constructing CKB Transaction for HTLC Timeout Unlock (JavaScript)
DESCRIPTION: This JavaScript code snippet prepares a CKB transaction to unlock an HTLC cell after the timeout period has passed. It initializes the CKB SDK, loads dependencies, retrieves necessary transaction/block information, constructs the transaction including header dependencies to prove time passage, and serializes the HTLC witness data indicating timeout using Molecule.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_25

LANGUAGE: JavaScript
CODE:
```
$ cd $TOP/htlc-runner
$ cat unlock_via_timeout.js
#!/usr/bin/env node

const { Molecule } = require('molecule-javascript')
const crc32 = require('crc32')
const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 8) {
  console.log(`Usage: ${process.argv[1]} <deployed tx hash> <htlc cell tx hash> <private key> <node URL> <header hash> <dry run>`)
  process.exit(1)
}

const deployedTxHash = process.argv[2]
const htlcCellTxHash = process.argv[3]
const privateKey = process.argv[4]
const nodeUrl = process.argv[5]
const headerHash = process.argv[6]
const dryrun = process.argv[7] === 'true'

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

  const htlcCellTx = await ckb.rpc.getTransaction(htlcCellTxHash)
  const htlcCellHeaderHash = htlcCellTx.txStatus.blockHash

  const publicKey = ckb.utils.privateKeyToPublicKey(privateKey)
  const publicKeyHash = `0x${ckb.utils.blake160(publicKey, 'hex')}`

  const lockScript = {
    hashType: secp256k1Dep.hashType,
    codeHash: secp256k1Dep.codeHash,
    args: publicKeyHash
  }
  const lockHash = ckb.utils.scriptToHash(lockScript)

  const unspentCells = await ckb.loadCells({
    lockHash
  })
  const totalCapacity = unspentCells.reduce((sum, cell) => sum + BigInt(cell.capacity), 0n)

  // For simplicity, we will just use 1 CKB as fee. On a real setup you
  // might not want to do this.
  const fee = 100000000n
  const htlcCellCapacity = 200000000000n

  const customSchema = JSON.parse(fs.readFileSync('../htlc-template/src/htlc-combined.json'))
  const htlcWitnessType = new Molecule(
    customSchema.declarations.find(d => d.name == "HtlcWitness"))
  const htlcWitness = htlcWitnessType.serialize([
    ['s', []],
    ['i', ['0x1', '0x0', '0x0', '0x0']]
  ])

  const transaction = {
    version: '0x0',
    cellDeps: [
      // Due to the requirement of load0 duktape binary, JavaScript source cell
      // should be the first one in cell deps
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x1"
        },
        depType: 'code'
      },
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x0"
        },
        depType: 'code'
      },
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [
      htlcCellHeaderHash,
      headerHash,
    ],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs: [
      {
        lock: lockScript,
        type: null,
        capacity: '0x' + (totalCapacity + htlcCellCapacity - fee).toString(16)
      }
    ],
    witnesses: unspentCells.map(_cell => '0x'),
    outputsData: [
      '0x',
      '0x'
    ]
  }
```

----------------------------------------

TITLE: Configure Molecule Dependency (v0.8+) in Cargo.toml
DESCRIPTION: Adds the Molecule Rust library dependency for versions 0.8 and later in a Cargo.toml file for CKB scripts. Disables default features for `no-std` and explicitly enables the `bytes_vec` feature, which is required for these versions in CKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/use-in-ckb-scripts.mdx#_snippet_1

LANGUAGE: Cargo.toml
CODE:
```
molecule = { version = "0.8.0", default-features = false, features = ["bytes_vec"] }
```

----------------------------------------

TITLE: Configure CKB Node API URL
DESCRIPTION: Shows how to export the API_URL environment variable to specify the address of the CKB node the CLI should connect to.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ckb-cli.mdx#_snippet_1

LANGUAGE: Shell
CODE:
```
export API_URL=http://127.0.0.1:8114
```

----------------------------------------

TITLE: Use entry_simulator! Macro in Simulator Lib (Rust)
DESCRIPTION: Invokes the `ckb_std::entry_simulator!` macro in the simulator library's `lib.rs`. This macro sets up the entry point for the native simulator, directing it to call the `program_entry` function from the main contract crate.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_23

LANGUAGE: Rust
CODE:
```
ckb_std::entry_simulator!(<contrace_name>::program_entry);
```

----------------------------------------

TITLE: Example: Get Live Cell Information
DESCRIPTION: Demonstrates using the `rpc get_live_cell` command to retrieve details about a specific live cell on the blockchain using its transaction hash and output index.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ckb-cli.mdx#_snippet_4

LANGUAGE: Shell
CODE:
```
ckb-cli rpc get_live_cell --tx-hash 0x4ec75b5a8de8d180853d5046760a99285c73283a5dc528f81d6ee056f5335172 --index 0
```

----------------------------------------

TITLE: Configure Simulator Library Cargo.toml (TOML)
DESCRIPTION: Configures the `Cargo.toml` for the simulator library. It adds the main contract crate and `ckb-std` as dependencies, enabling the `native-simulator` feature for both. It also sets the crate type to `cdylib` for dynamic library compilation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_22

LANGUAGE: TOML
CODE:
```
[dependencies]
contract = { path = "../../contracts/contract", features = ["native-simulator"] }
ckb-std = { version = "0.16.3", features = ["native-simulator"] }
[lib]
crate-type = ["cdylib"]
```

----------------------------------------

TITLE: Set Default CKB Version and Start Devnet
DESCRIPTION: Configures OffCKB to use a specific CKB version (e.g., 0.117.0) as the default for future `offckb node` commands, then immediately starts the development network using this newly set default version.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_5

LANGUAGE: bash
CODE:
```
offckb config set ckb-version 0.117.0
offckb node
```

----------------------------------------

TITLE: Main function for CKB VM fibonacci example (C)
DESCRIPTION: Entry point for the C program compiled from WebAssembly via Wasm2C. It parses a command-line argument, initializes the environment, calls the fibonacci function (Z_fibZ_ii), and returns the calculated result.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-4.md#_snippet_8

LANGUAGE: C
CODE:
```
int main(int argc, char** argv) {
  if (argc < 2) return 2;

  u8 x = atoi(argv[1]);

  Z_envZ_abortZ_viiii = &env_abort;

  init();

  u8 result = Z_fibZ_ii(x);

  return result;
}
```

----------------------------------------

TITLE: Parsing CKB Address String (Go)
DESCRIPTION: Explains how to decode an encoded CKB address string (e.g., Bech32) into an address.Address object. This allows access to the underlying lock script (addr.Script) and the network type (addr.Network) associated with the address.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_10

LANGUAGE: Go
CODE:
```
addr, err := address.Decode("ckt1qyqxgp7za7dajm5wzjkye52asc8fxvvqy9eqlhp82g")
if err != nil {
	// handle error
}
script := addr.Script
network := addr.Network
```

----------------------------------------

TITLE: Install CCC React Connector Package
DESCRIPTION: Installs the CCC connector package specifically for React applications using npm. This package provides React hooks and components for wallet integration.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_3

LANGUAGE: bash
CODE:
```
npm install @ckb-ccc/connector-react
```

----------------------------------------

TITLE: Initialize CKB Node for Mainnet - Bash
DESCRIPTION: Initializes the CKB node configuration files specifically for connecting to the mainnet. This command sets up the necessary directories and default configuration.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/run-mainnet-node.mdx#_snippet_3

LANGUAGE: bash
CODE:
```
ckb init --chain mainnet
```

----------------------------------------

TITLE: Preparing Compiled Rust Scripts for Debugging (Shell)
DESCRIPTION: Copies the compiled script binary to create a `.debug` version (with symbols) and then uses `llvm-objcopy` to strip debug information and symbols from the original binary, resulting in two files: one for debugging and one for deployment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_13

LANGUAGE: Shell
CODE:
```
cp <script_file> <script_file>.debug
llvm-objcopy --strip-debug --strip-all <script_file>
```

----------------------------------------

TITLE: Using CCC Molecule Basic Data Types (JavaScript)
DESCRIPTION: Illustrates the encoding and decoding of fundamental Molecule data types like Bytes, array, struct, table, vector, option, and union using the ccc.mol module provided by the CCC JavaScript SDK.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/ccc-molecule.mdx#_snippet_1

LANGUAGE: javascript
CODE:
```
import { ccc } from "@ckb-ccc/shell";

// Basic Usage

// Molecule Basic Types
// There is only one built-in primitive type in Molecule: byte.

// First usage:
//  - We can use ccc.mol.Bytes to represent a byte array.
console.log(ccc.mol.Bytes.encode("0x1234567890").toString());
console.log(
  ccc.mol.Bytes.decode(
    ccc.bytesFrom([5, 0, 0, 0, 18, 52, 86, 120, 144])
  ).toString()
);

// Composite Types
// array: An array consists of an item type and an unsigned integer.
console.log(
  ccc.mol
    .array(ccc.mol.Byte4, 2)
    .encode(["0x12345678", "0x12345678"])
    .toString()
);
console.log(
  ccc.mol.array(ccc.mol.Byte4, 2).decode("0x1234567812345678").toString()
);

// struct: A struct consists of a set of named and typed fields.
console.log(
  ccc.mol
    .struct({ a: ccc.mol.Byte4, b: ccc.mol.Byte4 })
    .encode({ a: "0x12345678", b: "0x12345678" })
    .toString()
);
console.log(
  ccc.mol
    .struct({ a: ccc.mol.Byte4, b: ccc.mol.Byte4 })
    .decode(ccc.bytesFrom([18, 52, 86, 120, 18, 52, 86, 120]))
);

// table: A table consists of a set of named and typed fields, same as struct.
console.log(
  ccc.mol
    .table({ a: ccc.mol.Byte4, b: ccc.mol.Byte4 })
    .encode({ a: "0x12345678", b: "0x12345678" })
    .toString()
);
console.log(
  ccc.mol
    .table({ a: ccc.mol.Byte4, b: ccc.mol.Byte4 })
    .decode(
      ccc.bytesFrom([
        20, 0, 0, 0, 12, 0, 0, 0, 16, 0, 0, 0, 18, 52, 86, 120, 18, 52, 86, 120,
      ])
    )
);

// vector: A vector contains only one item type.
console.log(
  ccc.mol.vector(ccc.mol.Byte4).encode(["0x12345678", "0x12345678"]).toString()
);
console.log(
  ccc.mol
    .vector(ccc.mol.Byte4)
    .decode(ccc.bytesFrom([2, 0, 0, 0, 18, 52, 86, 120, 18, 52, 86, 120]))
);

// option: An option contains only an item type.
console.log(ccc.mol.option(ccc.mol.Bytes).encode("0x68656c6c6f").toString());
console.log(
  ccc.mol.option(ccc.mol.Bytes).decode([5, 0, 0, 0, 104, 101, 108, 108, 111])
);

// union: A union contains a set of item types.
console.log(
  ccc.mol
    .union({ a: ccc.mol.Bytes, b: ccc.mol.Bytes })
    .encode({ type: "a", value: "0x12345678" })
    .toString()
);
console.log(
  ccc.mol
    .union({ a: ccc.mol.Bytes, b: ccc.mol.Bytes })
    .decode([0, 0, 0, 0, 4, 0, 0, 0, 18, 52, 86, 120])
);
```

----------------------------------------

TITLE: Debug Single CKB Script with Local Binary
DESCRIPTION: Replace the script being debugged with a local binary file for testing purposes. This command requires the transaction hash, the target script specified by --single-script, and the path to the binary file using the --bin option.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_23

LANGUAGE: Shell
CODE:
```
offckb debug <transaction-hash> --single-script <single-cell-script-option> --bin <path/to/binary/file>
```

----------------------------------------

TITLE: Create DOB Cluster with @ckb-ccc/ccc (TSX)
DESCRIPTION: Demonstrates creating a DOB Cluster on Nervos using `@ckb-ccc/ccc`. It includes defining the DOB0 pattern for the cluster description, calling `createSporeCluster`, handling transaction fee completion, sending the transaction, and waiting for confirmation. Requires `@ckb-ccc/ccc` and a signer/client setup.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_16

LANGUAGE: tsx
CODE:
```
import { ccc } from "@ckb-ccc/ccc";
import { client, signer } from "@ckb-ccc/playground";

function getExplorerTxUrl(txHash: string) {
  const isMainnet = client.addressPrefix === "ckb";
  const baseUrl = isMainnet
    ? "https://explorer.nervos.org"
    : "https://testnet.explorer.nervos.org";

  return `${baseUrl}/transaction/${txHash}`;
}

/**
 * Generate cluster description
 */
function generateClusterDescriptionUnderDobProtocol() {
  const clusterDescription = "A simple loot cluster";
  const dob0Pattern: ccc.spore.dob.PatternElementDob0[] = [
    {
      traitName: "BackgroundColor",
      dobType: "String",
      dnaOffset: 0,
      dnaLength: 1,
      patternType: "options",
      traitArgs: ["red", "blue", "green", "black", "white"],
    },
    {
      traitName: "Type",
      dobType: "Number",
      dnaOffset: 1,
      dnaLength: 1,
      patternType: "range",
      traitArgs: [10, 50],
    },
    {
      traitName: "Timestamp",
      dobType: "Number",
      dnaOffset: 2,
      dnaLength: 4,
      patternType: "rawNumber",
    },
  ];

  const dob0: ccc.spore.dob.Dob0 = {
    description: clusterDescription,
    dob: {
      ver: 0,
      decoder: ccc.spore.dob.getDecoder(client, "dob0"),
      pattern: dob0Pattern,
    },
  };

  return ccc.spore.dob.encodeClusterDescriptionForDob0(dob0);
}

/**
 * create cluster
 */
const { tx: clusterTx, id: clusterId } = await ccc.spore.createSporeCluster({
  signer,
  data: {
    name: "Simple loot",
    description: generateClusterDescriptionUnderDobProtocol(),
  },
});
await clusterTx.completeFeeBy(signer, 2000n);
const clusterTxHash = await signer.sendTransaction(clusterTx);
console.log(
  "Create cluster tx sent:",
  clusterTxHash,
  `Cluster ID: ${clusterId}`
);
await signer.client.waitTransaction(clusterTxHash);
console.log(
  "Create cluster tx committed:",
  getExplorerTxUrl(clusterTxHash),
  `Cluster ID: ${clusterId}`
);
```

----------------------------------------

TITLE: Add Native Simulator Feature (TOML)
DESCRIPTION: Configures the `tests` section in a TOML file to include the `native-simulator` feature from `ckb-testtool`, enabling the use of the native simulator for script testing and debugging.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_24

LANGUAGE: TOML
CODE:
```
native-simulator = [ "ckb-testtool/native-simulator" ]
```

----------------------------------------

TITLE: Creating New Project with bun (Bash)
DESCRIPTION: Uses the `create-ccc-app` CLI tool via bun to quickly scaffold a new project with built-in CCC wallet connection support.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/integrate-wallets/ccc-wallet.mdx#_snippet_4

LANGUAGE: Bash
CODE:
```
bunx create-ccc-app
```

----------------------------------------

TITLE: Define IPC Interface Trait (Rust)
DESCRIPTION: Define the communication interface between scripts using a Rust trait. Decorate the trait with the `#[ckb_script_ipc::service]` attribute macro, which automatically generates the required IPC implementation code. This trait should be shared between client and server scripts.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/ckb-script-ipc.mdx#_snippet_1

LANGUAGE: Rust
CODE:
```
#[ckb_script_ipc::service]
pub trait World {
    fn hello(name: String) -> Result<String, u64>;
}
```

----------------------------------------

TITLE: Preparing Input for UDT Transfer (JavaScript)
DESCRIPTION: Defines an `inputOutpoint` object using the transaction hash and index of a previously created UDT cell, which will serve as an input for a subsequent transaction, such as a UDT transfer.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_11

LANGUAGE: JavaScript
CODE:
```
let inputOutpoint = {
  txHash: rootUdtTxHash,
  index: "0x0"
};
```

----------------------------------------

TITLE: Send Transaction via Curl Bash
DESCRIPTION: This command uses curl to send a JSON RPC request to the CKB node's HTTP endpoint (http://localhost:8114) to send a transaction (send_transaction). It pipes a JSON payload containing the RPC method and parameters (the transaction object), via echo, removes newlines with tr -d '\n', and sends it as the request body with the correct content type.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/rpcs.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
echo '{
  "id": 3,
  "jsonrpc": "2.0",
  "method": "send_transaction",
  "params": [
    {
      "cell_deps": [
        {
          "dep_type": "code",
          "out_point": {
            "index": "0x0",
            "tx_hash": "0xa4037a893eb48e18ed4ef61034ce26eba9c585f15c9cee102ae58505565eccc3"
          }
        }
      ],
      "header_deps": [
        "0x7978ec7ce5b507cfb52e149e36b1a23f6062ed150503c85bbf825da3599095ed"
      ],
      "inputs": [
        {
          "previous_output": {
            "index": "0x0",
            "tx_hash": "0x365698b50ca0da75dca2c87f9e7b563811d3b5813736b8cc62cc3b106faceb17"
          },
          "since": "0x0"
        }
      ],
      "outputs": [
        {
          "capacity": "0x2540be400",
          "lock": {
            "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
            "hash_type": "data",
            "args": "0x"
          },
          "type": null
        }
      ],
      "outputs_data": [
        "0x"
      ],
      "version": "0x0",
      "witnesses": []
    }
  ]
}'\
| tr -d '\n' \
| curl -H 'content-type: application/json' -d @- \
http://localhost:8114
```

----------------------------------------

TITLE: Generate Molecule Schemas for JavaScript
DESCRIPTION: Installs the `moleculec` tool and uses it to generate JSON schema files from a Molecule definition (`htlc.mol`), first for the core schema and then combining it with the blockchain schema for use with `molecule-javascript`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_11

LANGUAGE: shell
CODE:
```
$ cd $TOP/htlc-template
$ cargo install moleculec
$ moleculec --language - --format json --schema-file htlc.mol > src/htlc.json
$ npx moleculec-js -ns src/htlc.json > src/htlc-combined.json
```

----------------------------------------

TITLE: Callee Script for Echoing Data (C)
DESCRIPTION: This C code snippet demonstrates a CKB script acting as a 'callee'. It retrieves inherited file descriptors, reads data from its designated standard input (a pipe connected to the caller), and writes the received data back to its designated standard output (a pipe connected back to the caller), effectively echoing the input.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/syscalls-for-script.mdx#_snippet_2

LANGUAGE: C
CODE:
```
#include <stdint.h>
#include <string.h>

#include "ckb_syscalls.h"

#define CKB_STDIN (0)
#define CKB_STDOUT (1)

// Function read_all reads from fd until an error or EOF and returns the data it read.
int ckb_read_all(uint64_t fd, void* buffer, size_t* length) {
    int err = 0;
    size_t read_length = 0;
    size_t full_length = *length;
    uint8_t* b = buffer;
    while (true) {
        size_t n = full_length - read_length;
        err = ckb_read(fd, b, &n);
        if (err == CKB_OTHER_END_CLOSED) {
            err = 0;
            *length = read_length;
            break;
        } else {
            if (err != 0) {
                goto exit;
            }
        }
        if (full_length - read_length == 0) {
            err = CKB_LENGTH_NOT_ENOUGH;
            if (err != 0) {
                goto exit;
            }
        }
        b += n;
        read_length += n;
        *length = read_length;
    }

exit:
    return err;
}

int main() {
    int err = 0;

    uint64_t fds[2] = {0};
    uint64_t fds_len = 2;
    err = ckb_inherited_file_descriptors(fds, &fds_len);
    if (err != 0) {
        goto exit;
    }

    uint8_t buffer[1024] = {0};
    size_t length;
    length = 1024;
    err = ckb_read_all(fds[CKB_STDIN], buffer, &length);
    if (err != 0) {
        goto exit;
    }
    err = ckb_write(fds[CKB_STDOUT], buffer, &length);
    if (err != 0) {
        goto exit;
    }
    err = ckb_close(fds[CKB_STDOUT]);
    if (err != 0) {
        goto exit;
    }

exit:
    return err;
}
```

----------------------------------------

TITLE: Deploying ckb-duktape REPL Binary on CKB - Node.js
DESCRIPTION: This Node.js snippet demonstrates how to use the @ckb-lumos/lumos library to create and send a transaction that deploys the compiled `build/repl` binary onto the CKB testnet. It initializes Lumos config, sets up RPC and Indexer, defines wallets, reads the binary file, creates a transaction skeleton, transfers funds, adds the binary data to an output cell, pays the fee, prepares signing entries, signs the transaction, and sends it.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_11

LANGUAGE: javascript
CODE:
```
$ node
Welcome to Node.js v20.12.0.
Type ".help" for more information.
>
>
> const lumos = require("@ckb-lumos/lumos");
> const indexer = new lumos.Indexer("https://testnet.ckb.dev/rpc");
> const rpc = new lumos.RPC("https://testnet.ckb.dev/rpc");
> lumos.config.initializeConfig(lumos.config.TESTNET);
> const wallet = {
  address:
    "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvwg2cen8extgq8s5puft8vf40px3f599cytcyd8",
  privkey: "0x6109170b275a09ad54877b82f7d9930f88cab5717d484fb4741ae9d1dd078cd6",
};
> const wallet2 = {
  address: "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2prryvze6fhufxkgjx35psh7w70k3hz7c3mtl4d",
  privkey: "0xace08599f3174f4376ae51fdc30950d4f2d731440382bb0aa1b6b0bd3a9728cd"
}

> const data = fs.readFileSync("./ckb-duktape/build/repl");
> data.byteLength
306040
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address],wallet2.address,"306240" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.data = "0x" + data.toString("hex");
  return outputs;
});
> txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton,[wallet.address],1000);
> txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
> const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
> const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
> const duktapeReplTxHash = await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: List Pre-Funded OffCKB Accounts
DESCRIPTION: Shows the command to print details of the 20 pre-funded development accounts included with OffCKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_34

LANGUAGE: bash
CODE:
```
offckb accounts
```

----------------------------------------

TITLE: Initialize CKB Script Project - Bash
DESCRIPTION: Command to initialize a new CKB script workspace using `cargo generate` and the `ckb-script-templates`. It prompts the user for a project name.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/a-minimal-script.mdx#_snippet_1

LANGUAGE: Bash
CODE:
```
alias create-ckb-scripts="cargo generate gh:cryptape/ckb-script-templates workspace"
create-ckb-scripts
```

----------------------------------------

TITLE: Building UDT Transfer Transaction Skeleton (Forging Attempt) - Lumos/CKB - JavaScript
DESCRIPTION: This snippet constructs a transaction skeleton for a UDT transfer using Lumos. It fetches cell data, defines input and output cells (with an invalid output amount intended to forge tokens), adds necessary cell dependencies for the UDT script and secp256k1 lock, calculates fees, prepares signing entries, signs the transaction, and attempts to send it, which is expected to fail due to the invalid token amount.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_9

LANGUAGE: JavaScript
CODE:
```
let udtCellWithStatus = await rpc.getLiveCell(inputOutpoint, true);
let blockHash = (await rpc.getTransaction(rootUdtTxHash)).txStatus.blockHash;
let blockNumber = (await rpc.getHeader(blockHash)).number;
let input = {
    outPoint: inputOutpoint,
    data: udtCellWithStatus.cell.data.content,
    cellOutput: udtCellWithStatus.cell.output,
    blockNumber
  }
let output = {
  data: bytes.hexify(Uint32LE.pack(2000000)),
  cellOutput: udtCellWithStatus.cell.output,
}
let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
txSkeleton = txSkeleton.update("inputs", (inputs) => inputs.push(input));
txSkeleton = txSkeleton.update("outputs", (outputs) => outputs.push(output));
txSkeleton = txSkeleton.update("witnesses", (witnesses) => witnesses.push("0x55000000100000005500000055000000410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"));
txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: duktapeTxHash,
    index: "0x0"
  },
  depType: "code"
})
txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: lumos.config.TESTNET.SCRIPTS['SECP256K1_BLAKE160']['TX_HASH'],
    index: lumos.config.TESTNET.SCRIPTS['SECP256K1_BLAKE160']['INDEX']
  },
  depType: lumos.config.TESTNET.SCRIPTS['SECP256K1_BLAKE160']['DEP_TYPE']
})
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet2.address], 3000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
let signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet2.privkey)).toArray();
let signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures)
await rpc.sendTransaction(signedTx)
```

----------------------------------------

TITLE: Load Schemas and Deserialize Script Args (JavaScript)
DESCRIPTION: Loads the generated Molecule schemas (`blockchain-combined.json` and `htlc-combined.json`) and uses `molecule-javascript` to deserialize the current CKB script and extract/deserialize its arguments (`HtlcArgs`). Includes helper functions for hex conversion.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_12

LANGUAGE: javascript
CODE:
```
const { Molecule } = require('molecule-javascript')
const schema = require('../schema/blockchain-combined.json')

const names = schema.declarations.map(declaration => declaration.name)
const scriptTypeIndex = names.indexOf('Script')
const scriptType = new Molecule(schema.declarations[scriptTypeIndex])

// Write your script logic here.
const customSchema = require('./htlc-combined.json')
const customNames = customSchema.declarations.map(d => d.name)

const htlcArgsIndex = customNames.indexOf('HtlcArgs')
const htlcArgsType = new Molecule(customSchema.declarations[htlcArgsIndex])

function bytesToHex(b) {
  return "0x" + Array.prototype.map.call(
    new Uint8Array(b),
    function(x) {
      return ('00' + x.toString(16)).slice(-2)
    }
  ).join('')
}

function hexStringArrayToHexString(a) {
  let s = "0x";
  for (let i = 0; i < a.length; i++) {
    s = s + a[i].substr(2)
  }
  return s
}

const current_script = scriptType.deserialize(bytesToHex(CKB.load_script(0)))
const args = hexStringArrayToHexString(current_script[2][1])
const htlcArgs = htlcArgsType.deserialize(args)

CKB.debug(`a: ${hexStringArrayToHexString(htlcArgs[0][1])}`)
CKB.debug(`b: ${hexStringArrayToHexString(htlcArgs[1][1])}`)
CKB.debug(`c: ${hexStringArrayToHexString(htlcArgs[2][1])}`)
```

----------------------------------------

TITLE: Install ckb-debugger CLI (Bash)
DESCRIPTION: Installs the ckb-standalone-debugger command-line tool using the Rust cargo package manager from its Git repository. Version ≥v0.113.0 is recommended.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_1

LANGUAGE: bash
CODE:
```
cargo install --git https://github.com/nervosnetwork/ckb-standalone-debugger ckb-debugger
```

----------------------------------------

TITLE: Molecule Schema for WitnessArgs
DESCRIPTION: Defines the structure of the WitnessArgs table used as a convention for serializing data within the `witnesses` field. It includes optional fields for lock, input type, and output type arguments required by scripts.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/witness.md#_snippet_0

LANGUAGE: Molecule
CODE:
```
table WitnessArgs {
    lock:                   BytesOpt,          // Lock args
    input_type:             BytesOpt,          // Type args for input
    output_type:            BytesOpt,          // Type args for output
}
```

----------------------------------------

TITLE: Deploy CKB Script (Default Config)
DESCRIPTION: Deploy the built CKB script to a specified network (devnet or testnet). This command assumes the `offckb.config.ts` file is located in the frontend directory.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_18

LANGUAGE: bash
CODE:
```
cd frontend && offckb deploy --network <devnet/testnet>
```

----------------------------------------

TITLE: Install CCC Core - NodeJS - Bash
DESCRIPTION: Installs the core CKB-CCC JavaScript SDK package for Node.js environments using npm. CCC is used for interacting with CKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_1

LANGUAGE: bash
CODE:
```
npm install @ckb-ccc/core
```

----------------------------------------

TITLE: Executing CKB Transfer Script (Bash)
DESCRIPTION: This command executes the TypeScript file (`wallet.ts`) containing the transfer transaction logic using `ts-node`. Running this command will initiate the CKB transfer as defined in the script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/lumos.mdx#_snippet_11

LANGUAGE: Bash
CODE:
```
npx ts-node wallet.ts
```

----------------------------------------

TITLE: Debug CKB Transaction with OffCKB (sh)
DESCRIPTION: Uses the `offckb debug` command to debug a specific transaction on the CKB chain identified by its hash, allowing inspection of script execution results.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_21

LANGUAGE: sh
CODE:
```
offckb debug --tx-hash 0x1464fec71bd95c4caa2a2640f1573850b25ba9c696c1bfdbe0dc7459717c734b
```

----------------------------------------

TITLE: Create Cluster using Spore SDK (JavaScript)
DESCRIPTION: Demonstrates how to create a Cluster using the `@spore-sdk/api` library, including setting metadata and specifying sender and receiver locks.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/spore-dob-0.mdx#_snippet_4

LANGUAGE: JavaScript
CODE:
```
import { createCluster } from '@spore-sdk/api';
import { bytifyRawString } from '@spore-sdk/helpers/buffer';

const account = ...;
const dob_metadata = {
  description: 'this is the description for cluster',
  dob: {
    ver: 0,
    decoder: {
      type: 'code_hash',
      hash: '...'
    },
    pattern: [["Age", "number", 1, 1, "range", [0, 100]]]
  }
};

const { txSkeleton, outputIndex } = await createCluster({
  data: {
    name: 'My First DOB Cluster',
    description: bytifyRawString(JSON.strinify(dob_metadata))
  },
  fromInfos: [account.address],
  toLock: account.lock
});
```

----------------------------------------

TITLE: Defining the CKB-VM spawn_cell Function Signature (Rust)
DESCRIPTION: Signature for the `spawn_cell` syscall in CKB-VM. It's a wrapper around `spawn` that locates the script using `code_hash` and `hash_type` instead of index and source.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-direct-cross-script-calling.mdx#_snippet_1

LANGUAGE: Rust
CODE:
```
pub fn spawn_cell(
  code_hash: &[u8],
  hash_type: ScriptHashType,
  argv: &[&CStr],
  inherited_fds: &[u64],
) -> Result<u64, SysError>;
```

----------------------------------------

TITLE: Fetch User's Nervos DAO Cells (React useEffect)
DESCRIPTION: Uses a React `useEffect` hook to asynchronously find and set the user's Nervos DAO cells when the signer object becomes available.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_23

LANGUAGE: TypeScript
CODE:
```
  useEffect(() => {
    if (!signer) {
      return;
    }

    (async () => {
      const daos = [];
      for await (const cell of signer.findCells(
        {
          script: await ccc.Script.fromKnownScript(
            signer.client,
            ccc.KnownScript.NervosDao,
            "0x"
          ),
          scriptLenRange: [33, 34],
          outputDataLenRange: [8, 9],
        },
        true
      )) {
        daos.push(cell);
        setDaos(daos);
      }
    })();
  }, [signer]);
```

----------------------------------------

TITLE: Signing Multisig Transaction Inputs (Python Pseudo Code)
DESCRIPTION: This pseudo-code outlines the steps involved in signing inputs for a multisig transaction on Nervos CKB. It demonstrates grouping inputs, creating a dummy lock field, hashing transaction components (including witnesses), signing the hash with multiple private keys, and placing signatures into the witness's lock field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-sign-a-tx.mdx#_snippet_2

LANGUAGE: python
CODE:
```
def sign_tx(pks, tx, multisig_script):
	# Group the transaction inputs for signing
    input_groups = compute_input_groups(tx.inputs)

    # Iterate through each group of inputs
    for indexes in input_groups:
        group_index = indexes[0]

        # Extract the required number of signatures 'm' from the multisig script
        m = multisig_script[2]

        # Create a dummy lock field with space for 'm' signatures
        dummy_lock = multisig_script + [0] * 65 * m

        # Deserialize the first witness and replace its lock field with the dummy lock
        witness = tx.witnesses[group_index]
        witness_args = witness.deserialize()
        witness_args.lock = dummy_lock

        # Initialize a new BLAKE2b hasher for the signature hash
        hasher = new_blake2b()

        # Hash the tx hash
        hasher.update(tx.hash())

        # Hash the first witness
        witness_len_bytes = len(serialize(witness_args)).to_le()
        assert(len(witness_len_bytes), 8)

        # Hash the length of witness
        hasher.update(witness_len_bytes)
        hasher.update(serialize(witness_args))

        # Hash the remaining witnesses in the group
        for i in indexes[1:]:
            witness = tx.witnesses[i]
            witness_len_bytes = len(witness).to_le()
            assert(len(witness_len_bytes), 8)
            hasher.update(witness_len_bytes)
            hasher.update(witness)

        # Hash additional witnesses not in any input group
        for witness in tx.witnesses[len(tx.inputs):]:
            witness_len_bytes = len(witness).to_le()
            assert(len(witness_len_bytes), 8)
            hasher.update(witness_len_bytes)
            hasher.update(witness)

        # Finalize the hasher to get the signature hash
        sig_hash = hasher.finalize()

        # Sign the transaction with each private key
        for (i, pk) in enumerate(pks):
            signature = pk.sign(sig_hash)

            # Place each signature in the appropriate position in the dummy lock field
            sig_offset = len(multisig_script) + i * 65 # Calculate the starting index for the signature
            witness_args.lock[sig_offset:sig_offset + 65] = signature
        # Serialize the updated witness arguments and update the transaction's witnesses list
        tx.witnesses[group_index] = serialize(witness_args)
```

----------------------------------------

TITLE: Deploying Caller Script with OffCKB
DESCRIPTION: Deploys the 'caller' script binary, located at build/release/caller, to the running offckb Devnet. This makes the script available for use in transactions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_17

LANGUAGE: sh
CODE:
```
offckb deploy --target build/release/caller
```

----------------------------------------

TITLE: Install CCC Core Package (NodeJS)
DESCRIPTION: Installs the core CCC package for Node.js environments using npm. This package provides the fundamental functionalities of the CCC SDK.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
npm install @ckb-ccc/core
```

----------------------------------------

TITLE: Installing Molecule Schema Compiler (Bash)
DESCRIPTION: Installs the official Molecule schema compiler and code generator (`moleculec`) using the Rust package manager, Cargo. The `--locked` flag ensures a reproducible build.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/tools.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
cargo install moleculec --locked
```

----------------------------------------

TITLE: Deploy Scripts to Testnet (Shell)
DESCRIPTION: Deploys the built CKB scripts to the Testnet using the `offckb` command-line tool. This command is executed from the frontend workspace.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_12

LANGUAGE: sh
CODE:
```
offckb deploy --network testnet
```

----------------------------------------

TITLE: Forging UDT on CKB using Lumos (JavaScript)
DESCRIPTION: Updates a transaction skeleton to include a UDT cell with a specific amount, adds the necessary script dependency, handles fee payment, prepares signing entries, signs the transaction, seals it, and sends it to the network to forge a new UDT.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_9

LANGUAGE: JavaScript
CODE:
```
const bytes = require("@ckb-lumos/lumos/codec").bytes;
const Uint32LE = require("@ckb-lumos/codec").number.Uint32LE;
txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = duktapeUdtTypeScript;
  cell.data = bytes.hexify(Uint32LE.pack(1000000));
  return outputs;
});
txSkeleton = lumos.helpers.addCellDep(txSkeleton, {
  outPoint: {
    txHash: duktapeTxHash,
    index: "0x0"
  },
  depType: "code"
});
txSkeleton = await lumos.commons.common.payFeeByFeeRate(txSkeleton, [wallet.address], 3000);
txSkeleton = lumos.commons.common.prepareSigningEntries(txSkeleton);
const signatures = txSkeleton.get("signingEntries").map((entry) => lumos.hd.key.signRecoverable(entry.message, wallet.privkey)).toArray();
const signedTx = lumos.helpers.sealTransaction(txSkeleton, signatures);
const rootUdtTxHash = await rpc.sendTransaction(signedTx);
```

----------------------------------------

TITLE: Calculating CKB Hash of Data (JavaScript)
DESCRIPTION: Calculates the CKB hash of a byte array representation of data using Lumos utilities. This hash is typically used as the `codeHash` for a script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-2.md#_snippet_16

LANGUAGE: JavaScript
CODE:
```
const duktapeCodeHash = lumos.utils.ckbHash(bytes.bytify("0x" + data.toString("hex")));
```

----------------------------------------

TITLE: Compile CKB C Script (Shell)
DESCRIPTION: Compiles the c.c source file into a RISC-V executable named 'c' using the cross-compilation toolchain inside the Docker container, applying optimizations for size.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-9.md#_snippet_7

LANGUAGE: Shell
CODE:
```
root@57b79063c965:/code# riscv64-unknown-elf-gcc -O3 -I ckb-duktape/deps/ckb-c-stdlib -I ckb-duktape/deps/molecule c.c -o c -Wl,-static -fdata-sections -ffunction-sections -Wl,--gc-sections -Wl,-s
```

----------------------------------------

TITLE: Compiling and Running WASI Example on CKB
DESCRIPTION: This shell script demonstrates the process of compiling a WASI-enabled WebAssembly example (.wast) to RISC-V using WAVM, generating AOT code, compiling a C main file that includes WASI ABI and the generated glue code, running the compilation within a Docker container with the RISC-V toolchain, patching the resulting binary, and finally executing it using a CKB runner script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_30

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ WAVM/build/bin/wavm compile --target-triple riscv64 WAVM/Examples/helloworld.wast helloworld_precompiled.wasm
$ wavm-aot-generator/target/release/wavm-aot-generator helloworld_precompiled.wasm helloworld_precompiled
$ cat << EOF > helloworld_wavm_main.c
#include "helloworld_precompiled_glue.h"
#include "abi/ckb_vm_wasi_abi.h"

/* main is already generated via wavm-aot-generator */
EOF
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20191209 bash
root@d28602dba318:/# cd /code
root@d28602dba318:/code# riscv64-unknown-elf-gcc -O3 -I ckb-c-stdlib -I wavm-aot-generator -I wabt/wasm2c helloworld_wavm_main.c wavm-aot-generator/abi/riscv64_runtime.S
helloworld_precompiled.o -o helloworld_wavm -Wl,-T wavm-aot-generator/abi/riscv64.lds
root@d28602dba318:/code# exit
exit
$ ckb-binary-patcher/target/release/ckb-binary-patcher -i helloworld_wavm -o helloworld_wavm_patched
$ RUST_LOG=debug ./runner.rb helloworld_wavm_patched 0x
DEBUG:<unknown>: script group: Byte32(0x86cfac3b49b8f97f913aa5a09d02ad1e5b1ab5be0be793815e9cb714ba831948) DEBUG OUTPUT: Hello World!

Run result: Ok(0)
Total cycles consumed: 20260
Transfer cycles: 17728, running cycles: 2532
```

----------------------------------------

TITLE: Rust struct for CKB CellOutput
DESCRIPTION: Defines the Rust structure for a CKB `CellOutput`, which represents the output of a transaction. It includes fields for `capacity`, the required `lock` script, and the optional `type` script. This structure is fundamental to understanding how cells are defined and validated in CKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-1.md#_snippet_0

LANGUAGE: Rust
CODE:
```
pub struct CellOutput {
    pub capacity: Capacity,
    pub lock: Script,
    #[serde(rename = "type")]
    pub type_: Option<Script>,
}
```

----------------------------------------

TITLE: Constructing & Sending HTLC Unlock Transaction (Secret String) (JavaScript)
DESCRIPTION: This JavaScript code constructs a CKB transaction to unlock an HTLC-guarded cell using a secret string. It defines cell dependencies, inputs, outputs, and witnesses, signs the transaction with a private key, and then either performs a dry run or sends the transaction to the CKB network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_24

LANGUAGE: JavaScript
CODE:
```
  ])

  const transaction = {
    version: '0x0',
    cellDeps: [
      // Due to the requirement of load0 duktape binary, JavaScript source cell
      // should be the first one in cell deps
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x1"
        },
        depType: 'code'
      },
      {
        outPoint: {
          txHash: deployedTxHash,
          index: "0x0"
        },
        depType: 'code'
      },
      {
        outPoint: secp256k1Dep.outPoint,
        depType: 'depGroup'
      }
    ],
    headerDeps: [],
    inputs: unspentCells.map(cell => ({
      previousOutput: cell.outPoint,
      since: '0x0'
    })),
    outputs: [
      {
        lock: lockScript,
        type: null,
        capacity: '0x' + (totalCapacity + htlcCellCapacity - fee).toString(16)
      }
    ],
    witnesses: unspentCells.map(_cell => '0x'),
    outputsData: [
      '0x',
      '0x'
    ]
  }
  transaction.inputs.push({
    previousOutput: {
      txHash: htlcCellTxHash,
      index: "0x0"
    },
    since: '0x0'
  })
  transaction.witnesses[0] = {
    lock: '',
    inputType: '',
    outputType: ''
  }
  const signedTransaction = ckb.signTransaction(privateKey)(transaction)
  signedTransaction.witnesses.push(htlcWitness)

  if (dryrun) {
    try {
      const result = await ckb.rpc.dryRunTransaction(signedTransaction)
      console.log(`Dry run success result: ${JSON.stringify(result, null, 2)}`)
    } catch (e) {
      console.log(`Dry run failure result: ${JSON.stringify(JSON.parse(e.message), null, 2)}`)
    }
  } else {
    const txHash = await ckb.rpc.sendTransaction(signedTransaction, 'passthrough')

    console.log(`Transaction hash: ${txHash}`)
    fs.writeFileSync('unlock_via_secret_string_result.txt', txHash)
  }
}

run()
```

----------------------------------------

TITLE: Configure Molecule Dependency (v0.7) in Cargo.toml
DESCRIPTION: Adds the Molecule Rust library as a dependency in a Cargo.toml file for CKB scripts. Specifies version 0.7 and disables default features to ensure `no-std` compatibility required for CKB environments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/use-in-ckb-scripts.mdx#_snippet_0

LANGUAGE: Cargo.toml
CODE:
```
molecule = { version = "0.7", default-features = false }
```

----------------------------------------

TITLE: Lumos Omnilock-Solana Integration Library (TypeScript)
DESCRIPTION: TypeScript code defining functions for interacting with CKB using Lumos, including transferring CKB, signing transactions with a Solana wallet (Phantom), and checking address capacity. It initializes Lumos configuration and sets up RPC and Indexer connections.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_6

LANGUAGE: typescript
CODE:
```
import { BI, helpers, Indexer, RPC, config, commons } from "@ckb-lumos/lumos";
import { common, omnilock } from "@ckb-lumos/lumos/common-scripts";
import { blockchain, bytify, hexify } from "@ckb-lumos/lumos/codec";
import { Config } from "@ckb-lumos/lumos/config";

const CKB_RPC_URL = "https://testnet.ckb.dev";
const rpc = new RPC(CKB_RPC_URL);
const indexer = new Indexer(CKB_RPC_URL);

export const CONFIG: Config = config.TESTNET;

config.initializeConfig(CONFIG);

declare global {
  interface Window {
    phantom: {
      solana: omnilock.solana.Provider;
    };
  }
}

export const solana = window.phantom.solana;

export function asyncSleep(ms: number): Promise<void> {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

interface Options {
  from: string;
  to: string;
  amount: string;
}

export async function transfer(options: Options): Promise<string> {
  let txSkeleton = helpers.TransactionSkeleton({ cellProvider: indexer });

  txSkeleton = await common.transfer(
    txSkeleton,
    [options.from],
    options.to,
    options.amount
  );
  txSkeleton = await common.payFeeByFeeRate(txSkeleton, [options.from], 1000);
  txSkeleton = commons.omnilock.prepareSigningEntries(txSkeleton);

  const signedMessage = await omnilock.solana.signMessage(
    txSkeleton.signingEntries.get(0)!.message,
    window.phantom.solana
  );

  const signedWitness = hexify(
    blockchain.WitnessArgs.pack({
      lock: commons.omnilock.OmnilockWitnessLock.pack({
        signature: bytify(signedMessage),
      }),
    })
  );

  txSkeleton = txSkeleton.update("witnesses", (witnesses) =>
    witnesses.set(0, signedWitness)
  );

  const signedTx = helpers.createTransactionFromSkeleton(txSkeleton);
  const txHash = await rpc.sendTransaction(signedTx, "passthrough");

  return txHash;
}

export async function capacityOf(address: string): Promise<BI> {
  const collector = indexer.collector({
    lock: helpers.parseAddress(address),
  });

  let balance = BI.from(0);
  for await (const cell of collector.collect()) {
    balance = balance.add(cell.cellOutput.capacity);
  }

  return balance;
}
```

----------------------------------------

TITLE: Example CKB Address Encoding Parameters and Output
DESCRIPTION: This snippet demonstrates the input parameters (code_hash, hash_type, args) used in the CKB address encoding process and shows the resulting full CKB address generated from these components.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/tech-explanation/ckb-address.mdx#_snippet_0

LANGUAGE: text
CODE:
```
== full address test ==
code_hash to encode:     9bd7e06f3ecf4be0f2fcd2188b23f1b9fcc88e5d4b65a8637b17723bbda3cce8
hash_type to encode:     01
with args to encode:     b39bbc0b3673c7d36450bc14cfcdad2d559c6c64
full address generated:  ckb1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqdnnw7qkdnnclfkg59uzn8umtfd2kwxceqxwquc4
```

----------------------------------------

TITLE: Generate Molecule Bindings (Folder) - OffCKB CLI
DESCRIPTION: Generate code bindings for a specific programming language from all Molecule schema files within a specified folder. Specify the input schema folder, the desired output folder path, and the target language.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_27

LANGUAGE: bash
CODE:
```
offckb mol --schema <path/to/mol/folder> --output-folder <path/to/output/folder> --lang <lang>
```

----------------------------------------

TITLE: Starting Devnet with offckb CLI (Bash)
DESCRIPTION: This command starts the CKB Devnet using the offckb CLI. It initializes the configuration, downloads necessary binaries if missing, and begins running the CKB node and miner. The output shows the initialization process and node version.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/_StartDevnet.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
offckb node
```

----------------------------------------

TITLE: Simplified Generated IPC Server Implementation - Rust
DESCRIPTION: Presents a simplified version of the server-side code generated by the `#[ckb_script_ipc::service]` macro. It implements the `ckb_script_ipc_common::ipc::Serve` trait, handling incoming requests, dispatching them to the actual service implementation, and returning the appropriate response.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/ckb-script-ipc.mdx#_snippet_7

LANGUAGE: rust
CODE:
```
impl<S> ckb_script_ipc_common::ipc::Serve for ServeWorld<S>
where
    S: World,
{
    type Req = WorldRequest;
    type Resp = WorldResponse;
    fn serve(
        &mut self,
        req: WorldRequest,
    ) -> ::core::result::Result<
        WorldResponse,
        ckb_script_ipc_common::error::IpcError,
    > {
        match req {
            WorldRequest::Hello { name } => {
                let ret = self.service.hello(name);
                Ok(WorldResponse::Hello(ret))
            }
        }
    }
}
```

----------------------------------------

TITLE: Initialize Native Simulator with ckb-script-templates (Shell)
DESCRIPTION: Executes a Makefile target `generate-native-simulator` provided by `ckb-script-templates`. This command initializes the Native Simulator setup for an existing script specified by the `CRATE` variable.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_18

LANGUAGE: Shell
CODE:
```
make generate-native-simulator CRATE=<Existing Script>
```

----------------------------------------

TITLE: Install CKB-SDK-Go Dependency (bash)
DESCRIPTION: Adds the `ckb-sdk-go` library as a dependency to the Go project using the `go get` command, fetching the specified version (v2) from the repository.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/go.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
go get -v github.com/nervosnetwork/ckb-sdk-go/v2
```

----------------------------------------

TITLE: Install CCC - Custom UI - Bash
DESCRIPTION: Installs the main CKB-CCC JavaScript SDK package for custom UI implementations using npm. CCC is used for interacting with CKB.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
npm install @ckb-ccc/ccc
```

----------------------------------------

TITLE: Creating a Script-Only Project with OffCKB (Bash)
DESCRIPTION: Initializes a project focused solely on CKB Script development without a frontend using the `offckb` CLI with the `--script` flag. Replace <my-script-project> with the desired project name.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_4

LANGUAGE: bash
CODE:
```
offckb create --script <my-script-project>
```

----------------------------------------

TITLE: Starting OffCKB Devnet
DESCRIPTION: Starts a local CKB Devnet node using the offckb tool, providing an environment for testing scripts and transactions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_16

LANGUAGE: sh
CODE:
```
offckb node
```

----------------------------------------

TITLE: Setting up CKB Debugger Environment (Shell)
DESCRIPTION: Commands to create a project directory, initialize npm, and install necessary CKB SDK and Molecule libraries for the CKB script debugging environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_2

LANGUAGE: shell
CODE:
```
$ cd $TOP
$ mkdir htlc-runner
$ cd htlc-runner
$ npm init
$ npm install --save @nervosnetwork/ckb-sdk-core
$ npm install --save @nervosnetwork/ckb-sdk-utils
$ npm install --save molecule-javascript
$ npm install --save crc32
```

----------------------------------------

TITLE: Calling Estimate Fee Rate RPC (Bash)
DESCRIPTION: This bash command uses curl to send a JSON-RPC request to the CKB node's RPC endpoint (http://localhost:8114) to invoke the 'estimate_fee_rate' method. The request includes the necessary JSON-RPC version, method name, and an empty params array, with the output piped to jq for formatting.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/turn-on-fee-estimator.mdx#_snippet_2

LANGUAGE: Bash
CODE:
```
echo '{ "id": 1, "jsonrpc": "2.0", "method": "estimate_fee_rate", "params": [] }' \
    | curl -s -H "Content-Type: application/json" -d @- "http://localhost:8114" \
    | jq
```

----------------------------------------

TITLE: Add Required Dependencies (Cargo.toml)
DESCRIPTION: Add the necessary crates (`ckb-script-ipc`, `ckb-script-ipc-common`, `serde`) to your project's `Cargo.toml` file. Remember to replace the version placeholders (`...`) with the latest available versions.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/ckb-script-ipc.mdx#_snippet_0

LANGUAGE: TOML
CODE:
```
ckb-script-ipc = { version = "..." }
ckb-script-ipc-common = { version = "..." }
serde = { version = "...", default-features = false, features = ["derive"] }

```

----------------------------------------

TITLE: Build Lumos and Check Config Manager (Bash)
DESCRIPTION: Commands to clone the Lumos repository, install dependencies, build the project, and verify the setup by running the config manager script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_7

LANGUAGE: bash
CODE:
```
git clone https://github.com/ckb-js/lumos.git
cd lumos
pnpm install
pnpm run build

# Check if it is working
npx ts-node misc/config-manager.ts
```

----------------------------------------

TITLE: Start CKB-CLI Interactive Mode
DESCRIPTION: Running the `ckb-cli` command without arguments launches the interactive mode, providing a convenient interface for executing commands.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ckb-cli.mdx#_snippet_2

LANGUAGE: Shell
CODE:
```
ckb-cli
```

----------------------------------------

TITLE: Get Block Info by Number (Rust)
DESCRIPTION: Example using the `CkbRpcClient` to fetch block information for block number 0 and print it as pretty-formatted JSON.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/rust.mdx#_snippet_6

LANGUAGE: Rust
CODE:
```
let block = ckb_client.get_block_by_number(0.into()).unwrap();
println!("block: {}", serde_json::to_string_pretty(&block).unwrap());
```

----------------------------------------

TITLE: Create and Compile AssemblyScript Fibonacci to WASM - Shell
DESCRIPTION: This shell script creates an AssemblyScript file named `fib.ts` containing a Fibonacci function and then compiles it into a WebAssembly binary (`fib.wasm`) using the `asc` compiler with optimization level O3.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_1

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ cat << EOF > fib.ts
export function fib(n: i32): i32 {
  var a = 0, b = 1;
    for (let i = 0; i < n; i++) {
        let t = a + b; a = b; b = t;
  }
  return b;
}
EOF
$ assemblyscript/bin/asc fib.ts -b fib.wasm -O3
```

----------------------------------------

TITLE: Unpacking Raw Spore Data (TypeScript)
DESCRIPTION: This line demonstrates how to use the `unpackToRawSporeData` function to extract the structured spore data from the raw output data of a retrieved CKB cell.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-dob.mdx#_snippet_6

LANGUAGE: TypeScript
CODE:
```
const sporeData = unpackToRawSporeData(cell.outputData);
```

----------------------------------------

TITLE: RawTransaction Structure Definition - Molecule Schema
DESCRIPTION: This defines the structure of a 'RawTransaction' in the Molecule serialization format. The transaction hash is calculated based on this structure, excluding the witness field.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-calculate-tx-hash.mdx#_snippet_1

LANGUAGE: Molecule Schema
CODE:
```
table RawTransaction {
    version:        Uint32,
    cell_deps:      CellDepVec,
    header_deps:    Byte32Vec,
    inputs:         CellInputVec,
    outputs:        CellOutputVec,
    outputs_data:   BytesVec,
}
```

----------------------------------------

TITLE: Deploying hello.bc Script (sh)
DESCRIPTION: Command and response for deploying the compiled `hello.bc` JavaScript code to the CKB devnet using `offckb deploy`. This makes the JS code available as a script on-chain.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_13

LANGUAGE: sh
CODE:
```
offckb deploy --target ./js/build/hello.bc --type-id
```

LANGUAGE: sh
CODE:
```
wait for tx confirmed on-chain...
tx committed.
hello.bc deployment.toml file /Library/Application Support/offckb-nodejs/devnet/contracts/hello.bc/deployment.toml generated successfully.
hello.bc migration json file /Library/Application Support/offckb-nodejs/devnet/contracts/hello.bc/migrations/2024-11-18-195031.json generated successfully.
done.
```

----------------------------------------

TITLE: Initializing CKB Script Project with offckb (Command)
DESCRIPTION: This command uses the `offckb` tool to initialize a new CKB script project. It creates a directory named `spawn-script` and sets up the necessary files and structure based on a template for developing CKB scripts.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
offckb create --script spawn-script
```

----------------------------------------

TITLE: WAVM C Wrapper for CKB - C
DESCRIPTION: This C code provides a wrapper for the WAVM precompiled WASM output. It includes necessary headers, defines a `wavm_env_abort` function that uses `ckb_exit`, loads input data from the CKB witness, calls the WAVM-exported `fib` function, and returns its result.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_4

LANGUAGE: C
CODE:
```
#include "fib_precompiled_glue.h"
#include "abi/ckb_vm_wasi_abi.h"
#include "ckb_syscalls.h"

void* wavm_env_abort(void* dummy, int32_t code, int32_t a, int32_t b, int32_t c)
{
  ckb_exit(code);

  return dummy;
}

int main() {
  uint32_t value;
  uint64_t len = 4;
  int ret = ckb_load_witness((void*) &value, &len, 0, 0,
                             CKB_SOURCE_GROUP_INPUT);
  if (ret != CKB_SUCCESS) {
    return ret;
  }
  if (len < 4) {
    return -1;
  }

  wavm_ret_int32_t wavm_ret = wavm_exported_function_fib(NULL, value);
  return wavm_ret.value;
}
```

----------------------------------------

TITLE: Defining Error Enum and Conversion (Rust)
DESCRIPTION: Defines an error handler module for the CKB script, including custom errors and conversion from system errors (`SysError`). This module is used to provide meaningful error codes when the script fails.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_6

LANGUAGE: Rust
CODE:
```
use ckb_std::error::SysError;

#[cfg(test)]
extern crate alloc;

#[repr(i8)]
pub enum Error {
    IndexOutOfBound = 1,
    ItemMissing,
    LengthNotEnough,
    Encoding,
    WaitFailure,
    InvalidFD,
    OtherEndClose,
    MaxVmSpawned,
    MaxFdCreated,
    // Add customized errors here...
}

impl From<SysError> for Error {
    fn from(err: SysError) -> Self {
        match err {
            SysError::IndexOutOfBound => Self::IndexOutOfBound,
            SysError::ItemMissing => Self::ItemMissing,
            SysError::LengthNotEnough(_) => Self::LengthNotEnough,
            SysError::Encoding => Self::Encoding,
            SysError::WaitFailure => Self::WaitFailure,
            SysError::InvalidFd => Self::InvalidFD,
            SysError::OtherEndClosed => Self::OtherEndClose,
            SysError::MaxVmsSpawned => Self::MaxVmSpawned,
            SysError::MaxFdsCreated => Self::MaxFdsCreated,
            SysError::Unknown(err_code) => panic!("unexpected sys error {}", err_code),
        }
    }
}
```

----------------------------------------

TITLE: Execute CKB Script and Dump VM State (Shell)
DESCRIPTION: This command executes a CKB script (`dump_load0`) that includes a syscall to dump the current VM state. The state is saved to `dump0.bin`. The output shows the execution details and the total cycles consumed during this initial run, which includes the setup and dumping process.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-9.md#_snippet_0

LANGUAGE: shell
CODE:
```
$ cd $TOP
$ RUST_LOG=debug ./runner.rb ckb-duktape/build/dump_load0 ckb-duktape-template/build/duktape.js dump0.bin
Executing: ckb-standalone-debugger/bins/target/release/ckb-debugger --tx-file tx.json --script-group-type lock -i 0 -e input -d dump0.bin
DEBUG:<unknown>: script group: Byte32(0xb5656359cbcd52cfa68e163cdd217657f0cfc533c909d13a1fdd8032f6b4f1f0) DEBUG OUTPUT: 0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947c219351b150b900e50a7039f1e448b844110927e5fd9bd30425806cb8ddff1fd970dd9a8
Run result: Ok(0)
Total cycles consumed: 20199104
Transfer cycles: 67352, running cycles: 20131752
```

----------------------------------------

TITLE: Rust Script Structure Definition
DESCRIPTION: This Rust struct defines the fundamental structure of a Script in Nervos CKB. It includes fields for `code_hash` to identify the script code, `hash_type` to specify how the code is located, and `args` for script-specific parameters.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/intro-to-script.mdx#_snippet_0

LANGUAGE: Rust
CODE:
```
pub struct Script {
    pub code_hash: H256,
    pub hash_type: ScriptHashType,
    pub args: JsonBytes,
}
```

----------------------------------------

TITLE: Importing Types in Molecule Schema Language (C Syntax)
DESCRIPTION: Shows the syntax for importing type definitions from another Molecule schema file. The import keyword is followed by the path to the schema file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/schema-language.mdx#_snippet_8

LANGUAGE: c
CODE:
```
import ../library/common_types;
```

----------------------------------------

TITLE: Add RISC-V Target - Linux - Bash
DESCRIPTION: Adds the riscv64imac-unknown-none-elf target to the Rust toolchain using rustup. This target is required for compiling CKB scripts on Linux.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_11

LANGUAGE: bash
CODE:
```
rustup target add riscv64imac-unknown-none-elf
```

----------------------------------------

TITLE: Build Lumos JavaScript/TypeScript SDK
DESCRIPTION: Provides a sequence of bash commands necessary to clone the Lumos repository, install its dependencies using pnpm, build the project, and verify the build by running a configuration manager script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_4

LANGUAGE: Bash
CODE:
```
# Build Lumos
git clone https://github.com/ckb-js/lumos.git
cd lumos
pnpm install
pnpm run build

# Check if it is working
npx ts-node misc/config-manager.ts
```

----------------------------------------

TITLE: Getting Block Information by Hash (Java)
DESCRIPTION: Example using the CKB-SDK-Java client to retrieve block details from the CKB node by providing the block hash.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/java.mdx#_snippet_5

LANGUAGE: Java
CODE:
```
byte[] blockHash = Numeric.hexStringToByteArray("0x77fdd22f6ae8a717de9ae2b128834e9b2a1424378b5fc95606ba017aab5fed75");
Block block = ckbApi.getBlock(blockHash);
System.out.println("Block: " + block);
```

----------------------------------------

TITLE: Add Dependencies and Complete Transaction - TypeScript
DESCRIPTION: Adds the necessary cell dependencies for the xUDT script to the transaction. It then completes the transaction by automatically selecting inputs to cover the required capacity and calculates/adds the transaction fee.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/create-token.mdx#_snippet_3

LANGUAGE: ts
CODE:
```
await tx.addCellDepsOfKnownScripts(signer.client, ccc.KnownScript.XUdt);
// additional 0.001 ckb for tx fee
// Complete missing parts for transaction
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);
```

----------------------------------------

TITLE: Caller Script for Spawning Process (C)
DESCRIPTION: This C code snippet demonstrates a CKB script acting as a 'caller'. It creates pipes to establish communication channels (mimicking stdin/stdout), spawns another script ('callee') inheriting these pipes, writes data to the callee's stdin, closes the write end, reads the echoed data from the callee's stdout, and verifies the received data.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/syscalls-for-script.mdx#_snippet_1

LANGUAGE: C
CODE:
```
#include <stdint.h>
#include <string.h>

#include "ckb_syscalls.h"

#define CKB_STDIN (0)
#define CKB_STDOUT (1)

// Function read_all reads from fd until an error or EOF and returns the data it read.
int ckb_read_all(uint64_t fd, void* buffer, size_t* length) {
    int err = 0;
    size_t read_length = 0;
    size_t full_length = *length;
    uint8_t* b = buffer;
    while (true) {
        size_t n = full_length - read_length;
        err = ckb_read(fd, b, &n);
        if (err == CKB_OTHER_END_CLOSED) {
            err = 0;
            *length = read_length;
            break;
        } else {
            if (err != 0) {
                goto exit;
            }
        }
        if (full_length - read_length == 0) {
            err = CKB_LENGTH_NOT_ENOUGH;
            if (err != 0) {
                goto exit;
            }
        }
        b += n;
        read_length += n;
        *length = read_length;
    }

exit:
    return err;
}

// Mimic stdio fds on linux
int create_std_fds(uint64_t* fds, uint64_t* inherited_fds) {
    int err = 0;

    uint64_t to_child[2] = {0};
    uint64_t to_parent[2] = {0};
    err = ckb_pipe(to_child);
    if (err != 0) {
        goto exit;
    }
    err = ckb_pipe(to_parent);
    if (err != 0) {
        goto exit;
    }

    inherited_fds[0] = to_child[0];
    inherited_fds[1] = to_parent[1];
    inherited_fds[2] = 0;

    fds[CKB_STDIN] = to_parent[0];
    fds[CKB_STDOUT] = to_child[1];

exit:
    return err;
}

int main() {
    int err = 0;

    const char* argv[] = {};
    uint64_t pid = 0;
    uint64_t fds[2] = {0};
    // it must be end with zero
    uint64_t inherited_fds[3] = {0};
    err = create_std_fds(fds, inherited_fds);
    if (err != 0) {
        goto exit;
    }

    spawn_args_t spgs = {
        .argc = 0,
        .argv = argv,
        .process_id = &pid,
        .inherited_fds = inherited_fds,
    };
    err = ckb_spawn(0, 3, 0, 0, &spgs);
    if (err != 0) {
        goto exit;
    }

    size_t length = 0;
    length = 12;
    err = ckb_write(fds[CKB_STDOUT], "Hello World!", &length);
    if (err != 0) {
        goto exit;
    }
    err = ckb_close(fds[CKB_STDOUT]);
    if (err != 0) {
        goto exit;
    }

    uint8_t buffer[1024] = {0};
    length = 1024;
    err = ckb_read_all(fds[CKB_STDIN], buffer, &length);
    if (err != 0) {
        goto exit;
    }
    err = memcmp("Hello World!", buffer, length);
    if (err != 0) {
        goto exit;
    }

exit:
    return err;
}
```

----------------------------------------

TITLE: Unlocking and Transferring CKB with Hash Lock (TypeScript)
DESCRIPTION: This asynchronous function constructs a CKB transaction to move a specified amount from a source address (secured by hash lock) to a destination address. It requires the user to provide the preimage for the hash lock in the witness, uses `ccc` to build the transaction, complete inputs, handle change, and finally sends the transaction via `cccClient`.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/simple-lock.mdx#_snippet_8

LANGUAGE: TypeScript
CODE:
```
// ...
export async function unlock(
  fromAddr: string,
  toAddr: string,
  amountInCKB: string
): Promise<string> {
  const fromScript = (await ccc.Address.fromString(fromAddr, cccClient)).script;
  const toScript = (await ccc.Address.fromString(toAddr, cccClient)).script;
  const readSigner = new ccc.SignerCkbScriptReadonly(cccClient, fromScript);

  // Build the full transaction
  const tx = ccc.Transaction.from({
    outputs: [{ lock: toScript }],
    outputsData: [],
  });

  // CCC transactions are easy to be edited
  tx.outputs.forEach((output, i) => {
    if (output.capacity > ccc.fixedPointFrom(amountInCKB)) {
      alert(`Insufficient capacity at output ${i} to store data`);
      return;
    }
    output.capacity = ccc.fixedPointFrom(amountInCKB);
  });

  // fill the witness with preimage
  const preimageAnswer = window.prompt("please enter the preimage: ");
  if (preimageAnswer == null) {
    throw new Error("user abort input!");
  }
  const newWitnessArgs = new ccc.WitnessArgs(
    stringToBytesHex(preimageAnswer) as `0x${string}`
  );
  console.log("newWitnessArgs: ", newWitnessArgs);
  tx.setWitnessArgsAt(0, newWitnessArgs);

  // Complete missing parts for transaction
  await tx.addCellDeps(offCKB.myScripts["hash-lock"]!.cellDeps[0].cellDep);
  await tx.completeInputsByCapacity(
    readSigner,
    ccc.fixedPointFrom(amountInCKB)
  );
  const balanceDiff =
    (await tx.getInputsCapacity(cccClient)) - tx.getOutputsCapacity();
  console.log("balanceDiff: ", balanceDiff);
  if (balanceDiff > ccc.Zero) {
    tx.addOutput({
      lock: fromScript,
    });
  }
  //await tx.completeFeeBy(readSigner, 1000);

  const txHash = await cccClient.sendTransaction(tx);
  console.log("Full transaction: ", tx.stringify());
  return txHash;
}
```

----------------------------------------

TITLE: Deploying HTLC Scripts and Testing Unlock (Shell)
DESCRIPTION: This comprehensive shell script snippet guides the user through building the HTLC template, making runner scripts executable, deploying necessary scripts to the CKB dev chain, creating an HTLC cell, and demonstrating dry-running unlock transactions using both secret string and timeout methods. Includes example command outputs.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_29

LANGUAGE: Shell
CODE:
```
# Make sure the HTLC script is successfully built first
$ cd $TOP/htlc-template
$ npm run build
# Ensure all scripts are runnable
$ cd $TOP/htlc-runner
$ chmod +x deploy_scripts.js
$ chmod +x create_htlc_cell.js
$ chmod +x unlock_via_secret_string.js
$ chmod +x unlock_via_timeout.js

# Let's first deploy duktape binary and JS scripts
$ ./deploy_scripts.js \
    ../ckb-duktape/build/load0 \
    ../htlc-template/build/duktape.js \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/"
This method is only for demo, don't use it in production
Transaction hash: 0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e008d636b8c9154f5c296e1f4

# Let's create a HTLC cell
$ ./create_htlc_cell.js \
    ../ckb-duktape/build/load0 \
    0xf30e1e8989fc3a4cb1e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/" \
    0x32e555f3ff8e135cece1351a6a2971518392c1e30375c1e006ad0ce8eac07947 \
    0xc219351b150b900e50a7039f1e448b844110927e5fd9bd30425806cb8ddff1fd
This method is only for demo, don't use it in production
Transaction hash: 0x7de8ea6b0d6cb9941e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd

# To save us the hassle of recreating cells, both unlock executables support
# a dry run mode, where we only does full transaction verification, but do not
# commit the success ones on chain.
# First let's show that we can unlock a HTLC cell given the right secret string
# and lock script
$ ./unlock_via_secret_string.js \
    0xf30e1e8989fc3a4cb1e52dacc85090f8ff74b05e008d636b8c9154f5c296e1f4 \
    0x7de8ea6b0d6cb9941e76976d1d55edf844c4fa81485e00fb8eba2d161b5830cd \
    0xd00c06bfd800d27397002dca6fb0993d5ba6399b4238b2f29ee9deb97593d2bc \
    "http://127.0.0.1:8114/" \
    "i am a secret" \
    true
This method is only for demo, don't use it in production
Dry run success result: {
  "cycles": "0xb1acc38"
}
```

----------------------------------------

TITLE: Defining HTLC Data Structures with Molecule
DESCRIPTION: This snippet shows the definition of `HtlcArgs` and `HtlcWitness` data structures using the Molecule serialization format. These structures are intended to hold custom arguments for an HTLC script, used in the `args` and `witnesses` fields of a CKB transaction. `HtlcArgs` contains two 32-byte fields and a 32-bit integer for public keys and hash, while `HtlcWitness` is a table containing optional fields for a secret string or a block header index.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_10

LANGUAGE: Shell
CODE:
```
cd $TOP/htlc-template
cat htlc.mol
```

LANGUAGE: Molecule
CODE:
```
array Uint32 [byte; 4];
array Byte32 [byte; 32];
vector Bytes <byte>;

struct HtlcArgs {
  a: Byte32,
  b: Byte32,
  hash: Uint32,
}

table HtlcWitness {
  s: Bytes,
  i: Uint32,
}
```

----------------------------------------

TITLE: Defining the CKB-VM spawn Function Signature (Rust)
DESCRIPTION: Signature for the low-level `spawn` syscall in CKB-VM. It creates a new process by executing a script identified by index and source, passing arguments and file descriptors.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-direct-cross-script-calling.mdx#_snippet_0

LANGUAGE: Rust
CODE:
```
pub fn spawn(
  index: usize,
  source: Source,
  place: usize,
  bounds: usize,
  spgs: &mut SpawnArgs,
) -> Result<u64, SysError>;
```

----------------------------------------

TITLE: Minimal CKB Script (Always Succeeds) - C
DESCRIPTION: This is the simplest possible CKB script written in C. It acts like a basic Unix executable and always returns 0 from the main function, which CKB interprets as script success. Note that this script is insecure for practical use as it provides no validation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_1

LANGUAGE: C
CODE:
```
int main(int argc, char* argv[])
{
  return 0;
}
```

----------------------------------------

TITLE: Creating HTLC Locked Cell on CKB using Node.js
DESCRIPTION: This Node.js script is designed to create a new cell on the CKB chain locked by a previously deployed HTLC script. It takes the deployed transaction hash, private key, node URL, and two lock hashes (A and B) as input, calculates the hash of the Duktape binary, loads necessary dependencies, and prepares to construct a transaction to create the HTLC-locked cell.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-7.md#_snippet_20

LANGUAGE: JavaScript
CODE:
```
#!/usr/bin/env node

const { Molecule } = require('molecule-javascript')
const crc32 = require('crc32')
const CKB = require("@nervosnetwork/ckb-sdk-core").default
const utils = require("@nervosnetwork/ckb-sdk-utils")
const process = require('process')
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 8) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <deployed tx hash> <private key> <node URL> <lock hash A> <lock hash B>`)
  process.exit(1)
}

const duktapeBinary = fs.readFileSync(process.argv[2])
const duktapeHash = blake2b(duktapeBinary)

const deployedTxHash = process.argv[3]
const privateKey = process.argv[4]
const nodeUrl = process.argv[5]
const lockHashA = process.argv[6]
const lockHashB = process.argv[7]

function hexStringToHexStringArray(s) {
  let arr = []
  for (let i = 2; i < s.length; i += 2) {
    arr.push('0x' + s.substr(i, 2))
  }
  return arr
}

const run = async () => {
  const ckb = new CKB(nodeUrl)
  const secp256k1Dep = await ckb.loadSecp256k1Dep()

```

----------------------------------------

TITLE: Dumping Lumos Transaction to JSON (JavaScript)
DESCRIPTION: Converts a Lumos `txSkeleton` object into a raw transaction JSON format using `rpc.paramsFormatter.toRawTransaction` and then writes the JSON string to a file named `failed-tx.json` using `fs.writeFileSync`. Requires Lumos SDK and Node.js `fs` module.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_7

LANGUAGE: JavaScript
CODE:
```
let txJson = rpc.paramsFormatter.toRawTransaction(lumos.helpers.createTransactionFromSkeleton(txSkeleton))
fs.writeFileSync('failed-tx.json', JSON.stringify(txJson, null, 2))
```

----------------------------------------

TITLE: Add RISC-V Target - Windows - Bash
DESCRIPTION: Adds the riscv64imac-unknown-none-elf target to the Rust toolchain using rustup. This target is required for compiling CKB scripts on Windows.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_14

LANGUAGE: bash
CODE:
```
rustup target add riscv64imac-unknown-none-elf
```

----------------------------------------

TITLE: Execute CKB Debugger Command (Ruby)
DESCRIPTION: Defines and executes a command-line command to run the CKB standalone debugger with a specified transaction file and script group type, targeting a specific input index.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_8

LANGUAGE: Ruby
CODE:
```
commandline = "ckb-standalone-debugger/bins/target/release/ckb-debugger --tx-file tx.json --script-group-type type -i 0 -e input"
STDERR.puts "Executing: #{commandline}"
exec(commandline)
```

----------------------------------------

TITLE: Building CKB Transaction in REPL (sh)
DESCRIPTION: REPL commands using the CCC SDK to construct a CKB transaction that utilizes the deployed `ckb-js-vm` and `hello.bc` scripts. It sets up the output cell's type script args and includes necessary cell dependencies.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_15

LANGUAGE: sh
CODE:
```
OffCKB > let baseScriptArgs = `0x0000${myScripts['hello.bc'].codeHash.slice(2)}0${ccc.hashTypeToBytes(myScripts['hello.bc'].hashType).toString()}`;
OffCKB > let baseScript = ccc.Script.from({
...   codeHash: myScripts["ckb-js-vm"].codeHash,
...   hashType: myScripts["ckb-js-vm"].hashType,
...   args: baseScriptArgs,
... })
```

LANGUAGE: sh
CODE:
```
OffCKB > let tx = ccc.Transaction.from({
...   outputs: [
...     {
...       lock: accounts[0].lockScript,
...       type: baseScript
...     },
...   ],
...  cellDeps: [
...   ...myScripts["ckb-js-vm"].cellDeps.map(c => c.cellDep),
...   ...myScripts['hello.bc'].cellDeps.map(c => c.cellDep)
...   ],
... });
```

----------------------------------------

TITLE: Clone Repository and Start Dapp
DESCRIPTION: Clones the example repository from GitHub, navigates into the simple-transfer directory, installs project dependencies using yarn, and starts the Dapp.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/simple-transfer/README.md#_snippet_0

LANGUAGE: Shell
CODE:
```
git clone https://github.com/nervosnetwork/docs.nervos.org.git
cd docs.nervos.org/examples/simple-transfer
yarn && yarn start
```

----------------------------------------

TITLE: Install Rust - Windows - Bash
DESCRIPTION: Installs the Rust toolchain on Windows using the Scoop package manager. Rust is needed for CKB script development.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/installation.mdx#_snippet_13

LANGUAGE: bash
CODE:
```
scoop install rust
```

----------------------------------------

TITLE: Profile Binary with ckb-debugger (Shell)
DESCRIPTION: Uses the `ckb-debugger` tool to generate profiling data for a specified binary (`fib`), saving the output to a file (`fib.pprof`). This data is used for visualization tools like flamegraphs.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_15

LANGUAGE: Shell
CODE:
```
ckb-debugger --bin fib --pprof fib.pprof
```

----------------------------------------

TITLE: Compiling and Running WASI Example on CKB
DESCRIPTION: This shell script demonstrates the process of compiling a WebAssembly Text (Wast) example using WAVM, generating Ahead-of-Time (AOT) code, linking it with the CKB runtime and WASI ABI, and finally executing the resulting binary on the CKB VM using a runner script.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-8.md#_snippet_26

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ WAVM/build/bin/wavm compile --target-triple riscv64 WAVM/Examples/helloworld.wast helloworld_precompiled.wasm
$ wavm-aot-generator/target/release/wavm-aot-generator helloworld_precompiled.wasm helloworld_precompiled
$ cat << EOF > helloworld_wavm_main.c
#include "helloworld_precompiled_glue.h"
#include "abi/ckb_vm_wasi_abi.h"

/* main is already generated via wavm-aot-generator */
EOF
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:bionic-20191209 bash
root@d28602dba318:/# cd /code
root@d28602dba318:/code# riscv64-unknown-elf-gcc -O3 -I ckb-c-stdlib -I wavm-aot-generator -I wabt/wasm2c helloworld_wavm_main.c wavm-aot-generator/abi/riscv64_runtime.S
helloworld_precompiled.o -o helloworld_wavm -Wl,-T wavm-aot-generator/abi/riscv64.lds
root@d28602dba318:/code# exit
exit
$ ckb-binary-patcher/target/release/ckb-binary-patcher -i helloworld_wavm -o helloworld_wavm_patched
$ RUST_LOG=debug ./runner.rb helloworld_wavm_patched 0x
DEBUG:<unknown>: script group: Byte32(0x86cfac3b49b8f97f913aa5a09d02ad1e5b1ab5be0be793815e9cb714ba831948) DEBUG OUTPUT: Hello World!

Run result: Ok(0)
Total cycles consumed: 20260
Transfer cycles: 17728, running cycles: 2532
```

----------------------------------------

TITLE: Generating New CKB Script 'caller' with make (Command)
DESCRIPTION: These commands navigate into the project directory and then execute the `make generate` command. This `make` target is used by the project template to create a new script module within the project, named `caller` in this case.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
cd caller-script
make generate
```

----------------------------------------

TITLE: Create Transaction Using Script as Type (JavaScript)
DESCRIPTION: Demonstrates creating a new transaction skeleton using Lumos and setting the previously defined `carrotTypeScript` as the `type` script of one of the output cells. It first creates a basic transfer transaction and then updates the first output cell to include the `carrotTypeScript`. This prepares the transaction to execute the script when the output cell is consumed.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-2.md#_snippet_8

LANGUAGE: js
CODE:
```
> let txSkeleton = lumos.helpers.TransactionSkeleton({ cellProvider: indexer });
> txSkeleton = await lumos.commons.common.transfer(txSkeleton,[wallet.address], wallet2.address,"100" + "00000000");
> txSkeleton.update("outputs", (outputs) => {
  let cell = outputs.first();
  cell.cellOutput.type = carrotTypeScript;
  return outputs;
});
```

----------------------------------------

TITLE: Debug Transaction with Replaced Script
DESCRIPTION: Uses CKB-Debugger to execute a transaction, replacing the original script with a local binary compiled from the provided C code (`always_failure`). Shows the execution result and cycle consumption.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_6

LANGUAGE: sh
CODE:
```
$ ckb-debugger --tx-file mock_tx.json --cell-index 0 --cell-type input --script-group-type lock --bin always_failure\n\nRun result: 1\nTotal cycles consumed: 1706(1.7K)\nTransfer cycles: 764, running cycles: 942
```

----------------------------------------

TITLE: Defining Array Type in Molecule Schema Language (C Syntax)
DESCRIPTION: Shows the syntax for defining a fixed-size array type in Molecule Schema Language. It specifies the array name, the type of its items (ItemType), and the fixed number of items (N).
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/schema-language.mdx#_snippet_2

LANGUAGE: c
CODE:
```
array ArrayName [ItemType; N];  // N is an unsigned integer
```

----------------------------------------

TITLE: Clone and Start Dapp Example (Generic)
DESCRIPTION: Clones the repository containing the example, navigates to the specific example directory, installs project dependencies using yarn, and starts the application.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/store-data-on-cell/README.md#_snippet_0

LANGUAGE: sh
CODE:
```
git clone https://github.com/nervosnetwork/docs.nervos.org.git
cd docs.nervos.org/examples/store-data-on-cell
yarn && yarn start
```

----------------------------------------

TITLE: Build CKB Transaction - OffCKB REPL
DESCRIPTION: Example demonstrating how to construct, complete inputs and fee, and send a CKB transaction using the built-in CKB Javascript SDK (CCC) within the OffCKB REPL environment.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_29

LANGUAGE: javascript
CODE:
```
let amountInCKB = ccc.fixedPointFrom(63);
let tx = ccc.Transaction.from({
  outputs: [
    {
      capacity: ccc.fixedPointFrom(amountInCKB),
      lock: accounts[0].lockScript,
    },
  ],
});
let signer = new ccc.SignerCkbPrivateKey(client, accounts[0].privkey);
await tx.completeInputsByCapacity(signer);
await tx.completeFeeBy(signer, 1000);
await mySigner.sendTransaction(tx)
```

----------------------------------------

TITLE: Compile JS to Binary with CKB-Debugger (sh)
DESCRIPTION: Compiles the `fib.js` script into a binary (`fib.bc`) using `ckb-debugger` and `ckb-js-vm`, filtering output to get the binary content.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_18

LANGUAGE: sh
CODE:
```
ckb-debugger --read-file js/fib.js --bin deps/ckb-js-vm -- -c | awk '/Run result: 0/{exit} {print}' | xxd -r -p > js/build/fib.bc
```

----------------------------------------

TITLE: OffCKB Project Creation Prompt Output (Bash)
DESCRIPTION: Shows the interactive prompt output when running `offckb create`, illustrating how to select a bare template using arrow keys from the available options.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/quick-start.mdx#_snippet_2

LANGUAGE: bash
CODE:
```
? Select a bare template
  Remix-Vite Bare Templates
> Next.js Bare Templates
---
A full-stack template with Next.js framework and ckb-script-templates,
[next.js,tailwindcss,ckb-script-templates,typescript,rust]
```

----------------------------------------

TITLE: Formatting and Saving CKB Transaction Skeleton to JSON (JavaScript)
DESCRIPTION: This JavaScript snippet shows how to convert a Lumos transaction skeleton into a raw transaction format suitable for debugging tools. It then serializes this raw transaction object to a JSON string and writes it to a file named "duktape-tx.json".
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_15

LANGUAGE: JavaScript
CODE:
```
let txJson = rpc.paramsFormatter.toRawTransaction(
  lumos.helpers.createTransactionFromSkeleton(txSkeleton)
);
fs.writeFileSync("duktape-tx.json", JSON.stringify(txJson, null, 2));
```

----------------------------------------

TITLE: Prepare CKB Transaction with Duktape and JS Script (JavaScript)
DESCRIPTION: This Node.js script reads the Duktape binary and a user-provided JavaScript script, calculates their Blake2b hashes, and generates a `tx.json` file. This file is formatted based on a `skeleton.json` template, embedding the Duktape binary, the JS script, and their hashes for use with the CKB debugger. It requires `fs` and a `utils` module (presumably from a CKB library) and expects paths to the Duktape binary and JS script as command-line arguments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-7.md#_snippet_5

LANGUAGE: JavaScript
CODE:
```
const fs = require('fs')

function blake2b(buffer) {
  return utils.blake2b(32, null, null, utils.PERSONAL).update(buffer).digest('binary')
}

if (process.argv.length !== 4) {
  console.log(`Usage: ${process.argv[1]} <duktape load0 binary> <js script>`)
  process.exit(1)
}

const duktape_binary = fs.readFileSync(process.argv[2])
const duktape_hash = blake2b(duktape_binary)
const js_script = fs.readFileSync(process.argv[3])

const data = fs.readFileSync('skeleton.json', 'utf8').
      replace("@DUKTAPE_HASH", utils.bytesToHex(duktape_hash)).
      replace("@SCRIPT_CODE", utils.bytesToHex(js_script)).
      replace("@DUKTAPE_CODE", utils.bytesToHex(duktape_binary))

fs.writeFileSync('tx.json', data)

const resolved_tx = JSON.parse(data)
const json_lock_script = resolved_tx.mock_info.inputs[0].output.lock
const lock_script = {
  codeHash: json_lock_script.code_hash,
  hashType: json_lock_script.hash_type,
  args: json_lock_script.args
}
const lock_script_hash = blake2b(utils.hexToBytes(utils.serializeScript(lock_script)))

console.log(`../ckb-standalone-debugger/bins/target/release/ckb-debugger -g lock -h ${utils.bytesToHex(lock_script_hash)} -t tx.json`)

```

----------------------------------------

TITLE: Start Next.js dApp Development Server (Bash)
DESCRIPTION: Runs the development server for the Next.js dApp. The network is determined by the NEXT_PUBLIC_NETWORK variable set in the .env file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/getting-started/blockchain-networks.mdx#_snippet_4

LANGUAGE: bash
CODE:
```
npm run dev
```

----------------------------------------

TITLE: Build CKB Script
DESCRIPTION: Compile the smart contract code within your project. This command typically uses a Makefile to orchestrate the build process.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_17

LANGUAGE: bash
CODE:
```
make build
```

----------------------------------------

TITLE: CKB UDT Type Script - JavaScript
DESCRIPTION: This JavaScript code implements a minimal UDT type script for the CKB blockchain. It validates that the sum of input UDT amounts equals the sum of output UDT amounts for standard transfers. For the initial issuance case (single input, single output), it verifies that the script argument matches the OutPoint of the first input cell, preventing unauthorized issuance or double-spending attempts.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-3.md#_snippet_2

LANGUAGE: JavaScript
CODE:
```
if (CKB.ARGV.length !== 1) {
  throw "Requires only one argument!";
}

var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var data_view = new DataView(buffer);
var output_index = 0;
var output_coins = 0;

while (true) {
  var c = CKB.load_cell(input_index, CKB.SOURCE.INPUT);
  if (typeof c === "number") {
    break;
  }
  var data = CKB.load_cell_data(input_index, CKB.SOURCE.INPUT);
  if (typeof data === "number") {
    throw "Cannot load data for input cell " + input_index;
  }
  data_view.setUint32(0, 0, true); // Little endian
  if (data.byteLength >= 4) {
    data_view.setUint32(0, new DataView(data).getUint32(0, true), true);
  }
  input_coins += data_view.getUint32(0, true);
  input_index += 1;
}

while (true) {
  var c = CKB.load_cell(output_index, CKB.SOURCE.OUTPUT);
  if (typeof c === "number") {
    break;
  }
  var data = CKB.load_cell_data(output_index, CKB.SOURCE.OUTPUT);
  if (typeof data === "number") {
    throw "Cannot load data for output cell " + output_index;
  }
  data_view.setUint32(0, 0, true); // Little endian
  if (data.byteLength >= 4) {
    data_view.setUint32(0, new DataView(data).getUint32(0, true), true);
  }
  output_coins += data_view.getUint32(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  if (!((input_index === 0) && (output_index === 1))) {
    throw "Invalid token issuing mode!";
  }
  var first_input = CKB.load_input(0, 0, CKB.SOURCE.INPUT);
  if (typeof first_input === "number") {
    throw "Cannot fetch the first input";
  }
  var hex_input_outpoint = Array.prototype.map
   .call(new Uint8Array(first_input), function (x) {
     return ("00" + x.toString(16)).slice(-2);
   })
   .join("")
   .slice(16); // remove the first 8 bytes of since
  var outpoint_arg = new TextDecoder().decode(CKB.ARGV[0]);
  if (outpoint_arg != hex_input_outpoint) {
    throw "Invalid creation argument!";
  }
}
```

----------------------------------------

TITLE: Compile C Code with RISC-V Toolchain (Error)
DESCRIPTION: Demonstrates attempting to compile the generated C code (`fib.c`) and the wrapper (`main.c`) using a RISC-V GCC toolchain within a Docker container. The output shows a linker error due to an undefined reference to the `Z_envZ_abortZ_viiii` function, indicating a missing WASM import implementation.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-4.md#_snippet_4

LANGUAGE: Shell
CODE:
```
$ sudo docker run --rm -it -v `pwd`:/code nervos/ckb-riscv-gnu-toolchain:xenial bash
(docker) $ cd /code
(docker) $ riscv64-unknown-elf-gcc -o fib_riscv64 -O3 -g main.c fib.c /code/wabt/wasm2c/wasm-rt-impl.c -I /code/wabt/wasm2c
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /tmp/ccfUDYhE.o: in function `__retain':
/code/fib.c:1602: undefined reference to `Z_envZ_abortZ_viiii'
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /tmp/ccfUDYhE.o: in function `i32_load':
/code/fib.c:42: undefined reference to `Z_envZ_abortZ_viiii'
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /tmp/ccfUDYhE.o: in function `f17':
/code/fib.c:1564: undefined reference to `Z_envZ_abortZ_viiii'
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /code/fib.c:1564: undefined reference to `Z_envZ_abortZ_viiii'
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /tmp/ccfUDYhE.o: in function `f6':
/code/fib.c:1011: undefined reference to `Z_envZ_abortZ_viiii'
/riscv/lib/gcc/riscv64-unknown-elf/8.3.0/../../../../riscv64-unknown-elf/bin/ld: /tmp/ccfUDYhE.o:/code/fib.c:1012: more undefined references to `Z_envZ_abortZ_viiii' follow
collect2: error: ld returned 1 exit status
(docker) $ exit
```

----------------------------------------

TITLE: Build Rust WASM and Convert to C using WABT
DESCRIPTION: Provides shell commands to clone a Rust project, build it for the wasm32-unknown-unknown target, and then use the WABT toolchain's wasm2c utility to convert the resulting WASM file into C code. This is demonstrated using the wasm-secp256k1-test project.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-8.md#_snippet_14

LANGUAGE: Shell
CODE:
```
$ cd $TOP
$ git clone https://github.com/nervosnetwork/wasm-secp256k1-test
$ cd wasm-secp256k1-test
$ cargo build --release --target=wasm32-unknown-unknown

$ cd $TOP
$ wabt/bin/wasm2c wasm-secp256k1-test/target/wasm32-unknown-unknown/release/wasm-secp256k1-test.wasm -o secp.c
```

----------------------------------------

TITLE: Benchmarking WABT Binary (1 Iteration)
DESCRIPTION: Runs the WABT compiled binary (secp_wabt) using the runner.rb script with input 0x01010000. This input likely encodes the number of iterations (1) and the specific test case (0x01). The output shows the run result and cycle consumption.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_22

LANGUAGE: Shell
CODE:
```
./runner.rb secp_wabt 0x01010000
```

----------------------------------------

TITLE: Starting CKB Debugger with Transaction File (Bash)
DESCRIPTION: This bash command launches the ckb-debugger tool. It specifies the transaction file to debug ("duktape.json"), the cell index (0), the cell type (output), and the script group type (type). This command starts the debugger and presents a duk> prompt for interacting with the script environment. Requires the ckb-debugger tool and the specified transaction file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_16

LANGUAGE: Bash
CODE:
```
ckb-debugger  --tx-file duktape.json --cell-index 0 --cell-type output --script-group-type type
duk>
```

----------------------------------------

TITLE: Configuring Fee Estimator Algorithm (TOML)
DESCRIPTION: This snippet shows how to specify the desired fee estimation algorithm within the [fee_estimator] section of the ckb.toml configuration file. The 'WeightUnitsFlow' algorithm is selected in this example as one of the available options.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/turn-on-fee-estimator.mdx#_snippet_0

LANGUAGE: TOML
CODE:
```
[fee_estimator]
# Specifies the fee estimate algorithm. Current options: ConfirmationFraction, WeightUnitsFlow.
algorithm = "WeightUnitsFlow"
```

----------------------------------------

TITLE: Installing offckb Globally (Shell)
DESCRIPTION: Use npm to install the offckb command-line tool globally. This tool is required to start a local CKB development network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/README.md#_snippet_1

LANGUAGE: Shell
CODE:
```
npm install -g offckb
```

----------------------------------------

TITLE: Run CKB Token Dapp on Devnet
DESCRIPTION: Sets the NETWORK environment variable to 'devnet', navigates to the Dapp directory, and starts the application configured for the local CKB devnet.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/examples/xudt/README.md#_snippet_4

LANGUAGE: Shell
CODE:
```
export NETWORK=devnet
cd xudt
yarn && yarn start
```

----------------------------------------

TITLE: VSCode Tasks for Starting and Stopping ckb-debugger (JSON)
DESCRIPTION: Configures VSCode `tasks.json` with two tasks: `StartDbg-Rust` which runs `ckb-debugger` in GDB mode for a specified script binary and listening address, and `StopCkbDebugger` which attempts to kill the `ckb-debugger` process.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/debug-script.mdx#_snippet_14

LANGUAGE: JSON
CODE:
```
{
    "label": "StartDbg-Rust",
    "isBackground": true,
    "type": "process",
    "command": "ckb-debugger",
    "args": [
        "--bin=rust/build/release/ckb-c1.debug",
        "--mode=gdb",
        "--gdb-listen=127.0.0.1:8000"
    ],
    "options": {
        "cwd": "${workspaceRoot}"
    }
},
{
    "label": "StopCkbDebugger",
    "type": "shell",
    "command": "killall ckb-debugger || true"
}
```

----------------------------------------

TITLE: Dumping CKB Transaction Details to JSON (Bash)
DESCRIPTION: This bash command uses the `ckb-transaction-dumper` tool to process a raw transaction JSON file ("duktape-tx.json") and output a more detailed, debugger-friendly JSON representation ("duktape.json"). This is a preparatory step for using the CKB debugger.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-5.md#_snippet_16

LANGUAGE: Bash
CODE:
```
ckb-transaction-dumper -t duktape-tx.json -o duktape.json
```

----------------------------------------

TITLE: Enabling RPC Experiment Module (TOML)
DESCRIPTION: This snippet demonstrates how to enable the 'Experiment' JSON-RPC API module in the [rpc] section of the ckb.toml file. Adding 'Experiment' to the 'modules' list makes experimental RPC methods, such as estimate_fee_rate, available for use.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/turn-on-fee-estimator.mdx#_snippet_1

LANGUAGE: TOML
CODE:
```
[rpc]
# List of API modules: ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]
modules = ["Net", "Pool", "Miner", "Chain", "Stats", "Subscription", "Experiment", "Debug", "Indexer"]
```

----------------------------------------

TITLE: Debug Single Cell Script with Binary - OffCKB CLI
DESCRIPTION: Debug a specific script within a transaction, replacing the original script code with a binary file from your local filesystem. This is useful for testing modified script code without deploying it.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_25

LANGUAGE: bash
CODE:
```
offckb debug <transaction-hash> --single-script <single-cell-script-option> --bin <path/to/binary/file>
```

----------------------------------------

TITLE: Including Error Module and Libraries (Rust)
DESCRIPTION: Includes the custom error module and necessary libraries from `ckb_std` and `core::ffi` required for using syscalls like `Spawn` and handling C-style strings.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_7

LANGUAGE: Rust
CODE:
```
mod error;
use ckb_std::syscalls::SpawnArgs;
use core::ffi::CStr;
```

----------------------------------------

TITLE: Generating AOT Code from WAVM Precompiled WASM
DESCRIPTION: Processes the WAVM precompiled WASM file (secp_precompiled.wasm) using the wavm-aot-generator to produce Ahead-of-Time (AOT) compiled code, likely an object file or assembly, named secp_precompiled.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-8.md#_snippet_16

LANGUAGE: Shell
CODE:
```
wavm-aot-generator/target/release/wavm-aot-generator secp_precompiled.wasm secp_precompiled
```

----------------------------------------

TITLE: Build and Run Omnilock-Metamask Example (Shell)
DESCRIPTION: These commands build the project, create a release build, navigate into the specific Omnilock-Metamask example directory, and then start the example application.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/omnilock.mdx#_snippet_8

LANGUAGE: Shell
CODE:
```
npm run build
npm run build-release
cd examples/omni-lock-metamask
npm start
```

----------------------------------------

TITLE: Deploy Binary Script with OffCKB (sh)
DESCRIPTION: Deploys the compiled `fib.bc` binary script to the CKB chain using the `offckb deploy` command with the `--type-id` flag.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_19

LANGUAGE: sh
CODE:
```
offckb deploy --target ./js/build/fib.bc --type-id
```

----------------------------------------

TITLE: Importing CCC Molecule Module (JavaScript)
DESCRIPTION: Demonstrates how to import the Molecule module from the `@ckb-ccc/core` package for use in JavaScript applications, enabling serialization and deserialization capabilities.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/serialization/ccc-molecule.mdx#_snippet_0

LANGUAGE: javascript
CODE:
```
import { mol } from "@ckb-ccc/core";
```

----------------------------------------

TITLE: Initialize CKB Script Project with OFFCKB
DESCRIPTION: Use the OFFCKB tool to create a new boilerplate project directory for CKB scripts. This command fetches a template from a specified or default repository.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/sudt-script.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
offckb create --script sudt-script
```

----------------------------------------

TITLE: Implementing Caller Function with Pipes and Spawn (Rust)
DESCRIPTION: Implements the core logic of the caller script. It creates two pipes for bidirectional communication, sets up arguments for the `spawn` syscall, executes another script (assumed to be in the first Cell Dep), reads the result from the pipe, and asserts the expected output.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/spawn-script.mdx#_snippet_9

LANGUAGE: Rust
CODE:
```
fn caller() -> Result<(), error::Error> {
    let (r1, w1) = ckb_std::syscalls::pipe()?;
    let (r2, w2) = ckb_std::syscalls::pipe()?;
    let to_parent_fds: [u64; 2] = [r1, w2];
    let to_child_fds: [u64; 3] = [r2, w1, 0]; // must ends with 0

    let mut pid: u64 = 0;
    let place = 0; // 0 means read from cell data
    let bounds = 0; // 0 means read to end
    let argc: u64 = 2;
    let argv = [
        CStr::from_bytes_with_nul(b"hello\0").unwrap().as_ptr(),
        CStr::from_bytes_with_nul(b"world\0").unwrap().as_ptr(),
    ];
    let mut spgs: SpawnArgs = SpawnArgs {
        argc,
        argv: argv.as_ptr(),
        process_id: &mut pid as *mut u64,
        inherited_fds: to_child_fds.as_ptr(),
    };
    ckb_std::syscalls::spawn(
        0,
        ckb_std::ckb_constants::Source::CellDep,
        place,
        bounds,
        &mut spgs,
    )?;

    let mut buf = [0; 256];
    let len = ckb_std::syscalls::read(to_parent_fds[0], &mut buf)?;
    assert_eq!(len, 10);
    buf[len] = 0;
    assert_eq!(
        CStr::from_bytes_until_nul(&buf).unwrap().to_str().unwrap(),
        "helloworld"
    );
    Ok(())
}
```

----------------------------------------

TITLE: Response for get_transaction RPC JSON
DESCRIPTION: This is the expected JSON response from the get_transaction RPC call. It contains the JSON RPC version, the result (an object detailing the transaction and its status), and the request ID. The status indicates whether the transaction is pending, committed, or unknown.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/node/rpcs.mdx#_snippet_5

LANGUAGE: json
CODE:
```
{
  "id": 4,
  "jsonrpc": "2.0",
  "result": {
    "transaction": {
      "cell_deps": [
        {
          "dep_type": "code",
          "out_point": {
            "index": "0x0",
            "tx_hash": "0xa4037a893eb48e18ed4ef61034ce26eba9c585f15c9cee102ae58505565eccc3"
          }
        }
      ],
      "hash": "0xa0ef4eb5f4ceeb08a4c8524d84c5da95dce2f608e0ca2ec8091191b0f330c6e3",
      "header_deps": [
        "0x7978ec7ce5b507cfb52e149e36b1a23f6062ed150503c85bbf825da3599095ed"
      ],
      "inputs": [
        {
          "previous_output": {
            "index": "0x0",
            "tx_hash": "0x365698b50ca0da75dca2c87f9e7b563811d3b5813736b8cc62cc3b106faceb17"
          },
          "since": "0x0"
        }
      ],
      "outputs": [
        {
          "capacity": "0x2540be400",
          "lock": {
            "code_hash": "0x28e83a1277d48add8e72fadaa9248559e1b632bab2bd60b27955ebc4c03800a5",
            "hash_type": "data",
            "args": "0x"
          },
          "type": null
        }
      ],
      "outputs_data": ["0x"],
      "version": "0x0",
      "witnesses": []
    },
    "cycles": "0x219",
    "time_added_to_pool": "0x187b3d137a1",
    "tx_status": {
      "block_hash": null,
      "status": "pending",
      "reason": null
    }
  }
}
```

----------------------------------------

TITLE: Calculate and Display DAO Cell Info (React)
DESCRIPTION: Calculates and formats the capacity of a DAO cell and potential profit or epoch difference for display in a React component.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/ccc.mdx#_snippet_22

LANGUAGE: TypeScript
CODE:
```
      className={`align-center ${
        isNew ? "text-yellow-400" : "text-orange-400"
      }`}
    >
      <div className="text-md flex flex-col">
        <span>
          {ccc.fixedPointToString(
            (dao.cellOutput.capacity / ccc.fixedPointFrom("0.01")) *
              ccc.fixedPointFrom("0.01")
          )}
        </span>
        {infos ? (
          <span className="-mt-1 text-sm">
            +
            {ccc.fixedPointToString(
              (infos[0] / ccc.fixedPointFrom("0.0001")) *
                ccc.fixedPointFrom("0.0001")
            )}
          </span>
        ) : undefined}
      </div>
      <div className="flex flex-col text-sm">
        {infos && tip ? (
          <div className="flex whitespace-nowrap">
            {ccc.fixedPointToString(
              ((parseEpoch(getClaimEpoch(infos[2], infos[3][1])) -
                parseEpoch(tip.epoch)) /
                ccc.fixedPointFrom("0.001")) *
                ccc.fixedPointFrom("0.001")
            )}{" "}
            epoch
          </div>
        ) : undefined}
        <span>{isNew ? "Redeem" : "Withdraw"}</span>
      </div>
    </BigButton>
  );
```

----------------------------------------

TITLE: Defining Extension Script Validation Function Signature - C
DESCRIPTION: Provides the C function signature expected for dynamically loaded extension scripts. The `validate` function is called by the xUDT script to check the validity of an extension, receiving parameters like owner mode status, extension index, and script arguments.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/common-scripts/xudt.mdx#_snippet_3

LANGUAGE: C
CODE:
```
int validate(int is_owner_mode, size_t extension_index, const uint8_t* args, size_t args_length);
```

----------------------------------------

TITLE: Validate CKB Token Transfer/Issuance (JavaScript)
DESCRIPTION: This JavaScript script, designed for the CKB VM, validates token transfers and issuance. It ensures input and output token amounts match for transfers. For issuance (no inputs, one output), it checks if the script argument matches the outpoint of the first input cell, preventing unauthorized creation. It uses CKB built-in functions to load cell data and transaction inputs.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-3.md#_snippet_7

LANGUAGE: JavaScript
CODE:
```
if (CKB.ARGV.length !== 1) {
  throw "Requires only one argument!";
}

var input_index = 0;
var input_coins = 0;
var buffer = new ArrayBuffer(4);
var ret = CKB.CODE.INDEX_OUT_OF_BOUND;

while (true) {
  ret = CKB.raw_load_cell_data(buffer, 0, input_index, CKB.SOURCE.GROUP_INPUT);
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    throw "Invalid input cell!";
  }
  var view = new DataView(buffer);
  input_coins += view.getUint32(0, true);
  input_index += 1;
}

var output_index = 0;
var output_coins = 0;

while (true) {
  ret = CKB.raw_load_cell_data(
    buffer,
    0,
    output_index,
    CKB.SOURCE.GROUP_OUTPUT
  );
  if (ret === CKB.CODE.INDEX_OUT_OF_BOUND) {
    break;
  }
  if (ret !== 4) {
    CKB.debug(ret);
    throw "Invalid output cell!";
  }
  var view = new DataView(buffer);
  output_coins += view.getUint32(0, true);
  output_index += 1;
}

if (input_coins !== output_coins) {
  if (!(input_index === 0 && output_index === 1)) {
    throw "Invalid token issuing mode!";
  }
  var first_input = CKB.load_input(0, 0, CKB.SOURCE.INPUT);
  if (typeof first_input === "number") {
    throw "Cannot fetch the first input";
  }
  var hex_input_outpoint = Array.prototype.map
    .call(new Uint8Array(first_input), function (x) {
      return ("00" + x.toString(16)).slice(-2);
    })
    .join("")
    .slice(16); // remove the first 8 bytes of since
  var outpoint_arg = new TextDecoder().decode(CKB.ARGV[0]);
  if (outpoint_arg !== hex_input_outpoint) {
    CKB.debug(outpoint_arg)
    CKB.debug(hex_input_outpoint)
    throw "Invalid creation argument!";
  }
}
```

----------------------------------------

TITLE: Calculating CKB Transaction Hash - Formula
DESCRIPTION: This formula shows the conceptual steps for calculating the transaction hash in CKB. It involves serializing the raw transaction (excluding witnesses) using Molecule and then applying the CKB-specific BLAKE2b hash function.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/how-tos/how-to-calculate-tx-hash.mdx#_snippet_0

LANGUAGE: CKB Concept
CODE:
```
ckbhash(molecule_encode(tx_excluding_witness))
```

----------------------------------------

TITLE: Run Fibonacci Benchmarks and Compare Results (Shell)
DESCRIPTION: These shell commands execute the `runner.rb` script with different fibonacci binary versions (`fib_wabt`, `fib_wavm_patched`, `fib_native`) and input values (`0x10000000`, `0x20000000`, `0x00010000`). The output shows the run result, total cycles consumed, transfer cycles, and running cycles for each execution, demonstrating performance differences.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script-course/intro-to-script-8.md#_snippet_13

LANGUAGE: Shell
CODE:
```
$ ./runner.rb fib_wabt 0x10000000
Run result: Ok(61)
Total cycles consumed: 549478
Transfer cycles: 6530, running cycles: 542948
$ ./runner.rb fib_wabt 0x20000000
Run result: Ok(-30)
Total cycles consumed: 549590
Transfer cycles: 6530, running cycles: 543060
$ ./runner.rb fib_wabt 0x00010000
Run result: Ok(29)
Total cycles consumed: 551158
Transfer cycles: 6530, running cycles: 544628
$ ./runner.rb fib_wavm_patched 0x10000000
Run result: Ok(61)
Total cycles consumed: 22402
Transfer cycles: 19696, running cycles: 2706
$ ./runner.rb fib_wavm_patched 0x20000000
Run result: Ok(-30)
Total cycles consumed: 22578
Transfer cycles: 19696, running cycles: 2882
$ ./runner.rb fib_wavm_patched 0x00010000
Run result: Ok(29)
Total cycles consumed: 25042
Transfer cycles: 19696, running cycles: 5346
$ ./runner.rb fib_native 0x10000000
Run result: Ok(61)
Total cycles consumed: 3114
Transfer cycles: 1137, running cycles: 1977
$ ./runner.rb fib_native 0x20000000
Run result: Ok(-30)
Total cycles consumed: 3226
Transfer cycles: 1137, running cycles: 2089
$ ./runner.rb fib_native 0x00010000
Run result: Ok(29)
Total cycles consumed: 4794
Transfer cycles: 1137, running cycles: 3657
```

----------------------------------------

TITLE: Deploy CKB Script (Specify Config Path)
DESCRIPTION: Deploy the built CKB script to a specified network, providing an explicit path to the `offckb.config.ts` file.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/sdk-and-devtool/offckb.mdx#_snippet_19

LANGUAGE: bash
CODE:
```
offckb deploy --network <devnet/testnet> --config <file-path-to-your-offckb.config.ts-file>
```

----------------------------------------

TITLE: Run CKB Example Application (Bash)
DESCRIPTION: This command installs project dependencies using `yarn`, sets the `NETWORK` environment variable to `devnet`, and then starts the application using `yarn start`. This is typically used to run the example against a local development network.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/dapp/_SetupProjectContent.mdx#_snippet_0

LANGUAGE: bash
CODE:
```
yarn && NETWORK=devnet yarn start
```

----------------------------------------

TITLE: Saving CKB Transaction Skeleton to JSON File (JS)
DESCRIPTION: This JavaScript snippet converts a Lumos transaction skeleton into a raw transaction object using the RPC formatter. It then serializes the raw transaction object to a JSON string with indentation and writes it to a file named "duktape-tx.json" using the Node.js fs module. Requires a txSkeleton object, an RPC client with a params formatter, and the fs module.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/blog/intro-to-script-5.md#_snippet_14

LANGUAGE: JavaScript
CODE:
```
let txJson = rpc.paramsFormatter.toRawTransaction(
  lumos.helpers.createTransactionFromSkeleton(txSkeleton)
);
fs.writeFileSync("duktape-tx.json", JSON.stringify(txJson, null, 2));
```

----------------------------------------

TITLE: ckb-debugger Test Output (Bash)
DESCRIPTION: Displays the expected output from running the ckb-js-vm test script via ckb-debugger. It shows script logs, the execution result (0 indicates success), and the cycles consumed.
SOURCE: https://github.com/nervosnetwork/docs.nervos.org/blob/develop/website/docs/script/js-script.mdx#_snippet_4

LANGUAGE: bash
CODE:
```
Script log: Run from file, local access enabled. For Testing only.
Script log: hello, world
Run result: 0
All cycles: 3016765(2.9M)
```