This logic will forbid user to load partial data by syscall.

Consider a case we just want load the code_hash from a script and check the value, with underlying syscall we just call it by:

let offset = 16;
let mut buf = [0u8; 32]
let ret = syscall(&mut buf, offset, ....);

When I upgrade the version of ckb-std from 0.14.0 to 0.15.1 for https://github.com/xcshuan/ecdsa-lock, I can't test the script with env CAPSULE_TEST_ENV=release bacause issue below:

thread 'tests::test_ecverify' panicked at 'pass verification: Error { kind: Script, inner: TransactionScriptError { source: Inputs[0].Lock, cause: VM Internal Error: MemWriteOnExecutablePage } }', src/tests.rs:79:10

Debug mode is ok.

It would be very beneficial if these error messages had more detail in the documentation. As it is right now, there is not enough detail to give any meaningful hints to the developer on how to fix the problem.

https://github.com/nervosnetwork/ckb-std/blob/master/src/error.rs#L3-L14
https://nervosnetwork.github.io/ckb-std/riscv64imac-unknown-none-elf/doc/ckb_std/error/enum.SysError.html

An example of this is SysError::ItemMissing, which was encountered today by phroi, the developer working on iCKB. He received this error while sending a transaction. He was unable to find the proper documentation for the error. After several hours he figured out it was due to the header deps not being added to the transaction properly.

A helpful error description for each of these would explain it enough that a developer should be able to make a reasonable determination of what could be tried next.

• Where is this error generated from?
• What does the error mean?
• What are common developer mistakes that could lead to this error?

If it succeeds, it won't return.

(But ! is usable in stable yet, if we don't want to use the nightly feature, we can use Infallible instead.)

In the contract I'm implementing, I need to find an output that matches the absolute index of the input in the group.

let input = load_input(index, Source::GroupInput)?;
let input_absolute_index = calculate_input_absolute_index(&input)?;
let output = load_cell(input_absolute_index, Source::Output)?;

fn calculate_input_absolute_index(input: &CellInput) -> Result<usize, Error> {
    load_transaction()?
        .raw()
        .inputs()
        .into_iter()
        .position(|i| i.as_bytes() == input.as_bytes())
        .ok_or(Error::ItemMissing)
}

However, the method I'm using is quite inefficient.

Original discussion: nervosnetwork/capsule#72

While using ckb-std, I noticed that ckb-std github pages docs do not report CKB2021:

On the other hand the library itself clearly supports CKB2021:

Keep up the great work,
Phroi 💪

Hey Cryptape, iCKB here 👋 I was updating iCKB Logic implementation to use ckb-std 0.15.3 and I stumbled upon an apparent issue:

• I'm unable to unpack the result of load_header(index, source)?.raw().dao()
• The only implementation to obtain accumulated_rate that works is:

    let d = load_header(index, source)?.raw().dao();
    let accumulated_rate = u64::from_le_bytes([
        u8::from(d.nth8()),
        u8::from(d.nth9()),
        u8::from(d.nth10()),
        u8::from(d.nth11()),
        u8::from(d.nth12()),
        u8::from(d.nth13()),
        u8::from(d.nth14()),
        u8::from(d.nth15()),
    ]);

So my questions are:

1. What's the best way to extract accumulated_rate?
2. Can you double check that the unpack of Byte32 is working as expected?

As when I try to unpack dao_data I get the following error:

Compiling ickb_logic v1.2.0 (/home/user/ickb/ickb_logic/contracts/ickb_logic)
error[E0599]: no method named `unpack` found for struct `Byte32` in the current scope
  --> contracts/ickb_logic/src/utils.rs:57:14
   |
57 |     dao_data.unpack();
   |              ^^^^^^ method not found in `Byte32`

warning: unused import: `ckb_types::prelude::Unpack`
 --> contracts/ickb_logic/src/utils.rs:5:5
  |
5 |     ckb_types::prelude::Unpack,
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

Keep up the Great Work,
Phroi

In the partial sign scenario, it is necessary to get all the inputs in the group, but at the moment I can only rely on the error definition：

   let mut i = 0;
    loop {
        match load_input(i, Source::GroupInput) {
            Ok(_) => {
                ...
                i += 1;
            }
            Err(SysError::IndexOutOfBound) => break,
            Err(_) => return Err(Error::LoopGroupInputs),
        }
    }

It would be very convenient if load_inputs were provided.

The contract source code in ckb-std/tree/master/test

Now that the default alloc error handler is stabilized, it's possible to build no_std + alloc programs with stable rust.

A drawback is that the default alloc error handler pulls in fmt, so it might increase binary size.

Issue

I have the following code:

#[cfg(debug_assertions)]
use ckb_std::ckb_types::prelude::*;

debug!("script hash = {:#x}", script_hash.pack());

When set debug_assertions = false, the above could NOT be compiled.

Description

When users don't want to print the debug messages, all functions in debug!(..), such as script_hash.pack() in above code, should be ignored and they should never be executed.

I found that the codes below hardcode let hash_type: u8 = 0; which means loading dynamic library through the hash of outputs_data 😓:

But loading a dynamic library through type ID is the best practice. So, could you please change it to an argument which can be chosen by the crate users?

THX for any help. 😄

calc_script_hash is a wildly used method. We should support it in ckb-std.

https://github.com/nervosnetwork/ckb/blob/b996deff010b8f14d9b80980fc443cb282edfc44/util/types/src/extension/calc_hash.rs#L87

Dynamic loading is discouraged.

And when there's no C code that needs to be built, the C compiler is not necessary.

Related: nervosnetwork/capsule#114 (comment)

Syscall results are currently raw bytes.
Are there any plans to deserialize syscall results into structs using nostd molecule?