calls.rs

use super::*;
use cellscript_artifact_checker::runtime_contract::{RuntimeAvailability, RuntimeHelper};

impl CodeGenerator {
    fn emit_commitment_open_call(&mut self, dest: Option<&IrVar>, args: &[IrOperand]) -> Result<()> {
        self.emit("# cellscript committed-state: validate explicit fixed-width opening");
        let Some(dest) = dest else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };
        let [expected, opening] = args else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };
        let IrOperand::Var(opening_var) = opening else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };
        let IrType::Opening(value_type) = &opening_var.ty else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };
        // The packed-hash domain is the existing source/wire spelling contract,
        // rendered from the retained type; it is never parsed as type evidence.
        let inner_name = value_type.source_text();
        let Some(width) = self.fixed_named_type_width(&opening_var.ty) else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };
        let Some(expected_source) = self.expected_fixed_byte_source(expected, 32) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(opening_source) = self.expected_fixed_byte_source(opening, width) else {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        };

        let mut header = crate::commitment_contract::PACKED_HASH_DOMAIN_PREFIX.to_vec();
        header.extend_from_slice(inner_name.as_bytes());
        header.push(0);
        header.extend_from_slice(&(width as u32).to_le_bytes());
        let total_width = header.len() + width;
        if total_width + 32 > RUNTIME_SCRATCH_BUFFER_SIZE {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        }
        let buffer_offset = self.runtime_scratch_buffer_offset();
        let digest_offset = buffer_offset + total_width;
        for (index, byte) in header.iter().enumerate() {
            self.emit(format!("li t0, {}", byte));
            self.emit_stack_store_byte("t0", buffer_offset + index);
        }
        let header_ready = self.fresh_label("commitment_opening_header_ready");
        self.emit_label(&header_ready);
        self.emit_prepare_fixed_byte_source(&opening_source, width, "typed opening witness");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &opening_source) {
            self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
            return Ok(());
        }
        self.emit_sp_addi("a1", buffer_offset + header.len());
        self.emit(format!("li a2, {}", width));
        self.emit("call __cellscript_memcpy_fixed");
        self.emit_sp_addi("a0", buffer_offset);
        self.emit(format!("li a1, {}", total_width));
        self.emit_sp_addi("a2", digest_offset);
        self.emit("call __ckb_hash_blake2b_var");
        self.emit_return_on_syscall_error(CellScriptRuntimeError::SyscallFailed);

        self.emit_prepare_fixed_byte_source(&expected_source, 32, "typed commitment");
        self.emit_sp_addi("a0", digest_offset);
        if !self.emit_fixed_byte_source_pointer_or_const_to("a1", &expected_source) {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        self.emit("li a2, 32");
        self.emit("call __cellscript_memcmp_fixed");
        let verified = self.fresh_label("commitment_opening_verified");
        self.emit(format!("beqz a0, {}", verified));
        self.emit_fail(CellScriptRuntimeError::CommitmentOpeningMismatch);
        self.emit_label(&verified);

        // The value is materialized only after the digest comparison succeeds.
        self.emit_prepare_fixed_byte_source(&opening_source, width, "validated typed opening");
        if let Some(dest_offset) = self.fixed_byte_local_offsets.get(&dest.id).copied() {
            if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &opening_source) {
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            }
            self.emit_sp_addi("a1", dest_offset);
            self.emit(format!("li a2, {}", width));
            self.emit("call __cellscript_memcpy_fixed");
            self.emit_sp_addi("t0", dest_offset);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        } else {
            if width > 8 || !self.emit_fixed_byte_source_pointer_or_const_to("t4", &opening_source) {
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            }
            self.emit("li t0, 0");
            for byte_index in 0..width {
                self.emit_load(LoadOp::ByteUnsigned, "t1", "t4", byte_index);
                if byte_index != 0 {
                    self.emit(format!("slli t1, t1, {}", byte_index * 8));
                }
                self.emit("or t0, t0, t1");
            }
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        }
        Ok(())
    }

    fn emit_ckb_fixed_hash_call(&mut self, dest: Option<&IrVar>, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        self.emit(format!("# call {}", func));
        let Some(dest) = dest else {
            self.emit("# cellscript abi: fail closed because hash helper result has no destination");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(dest_offset) = self.fixed_byte_local_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: fail closed because hash helper output buffer was not allocated");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        if helper == RuntimeHelper::CkbScriptHash {
            if args.len() != 3 {
                self.emit("# cellscript abi: fail closed because script_hash needs code_hash, hash_type, and args");
                self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                return Ok(());
            }
            let Some(code_hash) = self.expected_fixed_byte_source(&args[0], 32) else {
                self.emit("# cellscript abi: fail closed because Script code_hash is not a materializable Hash");
                self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                return Ok(());
            };
            let Some(args_width) = operand_fixed_byte_width(&args[2]).or_else(|| match &args[2] {
                IrOperand::Var(var) => self.fixed_byte_like_width(&var.ty),
                IrOperand::Const(_) => None,
            }) else {
                self.emit("# cellscript abi: fail closed because Script args do not have a static fixed-byte width");
                self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                return Ok(());
            };
            if args_width > crate::CKB_SCRIPT_HASH_MAX_ARGS_BYTES {
                self.emit("# cellscript abi: fail closed because canonical Script preimage exceeds the bounded buffer");
                self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                return Ok(());
            }
            let script_args = if args_width == 0 {
                None
            } else {
                let Some(source) = self.expected_fixed_byte_source(&args[2], args_width) else {
                    self.emit("# cellscript abi: fail closed because Script args are not materializable");
                    self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                    return Ok(());
                };
                Some(source)
            };
            self.emit_prepare_fixed_byte_source(&code_hash, 32, "canonical Script code_hash");
            if let Some(source) = &script_args {
                self.emit_prepare_fixed_byte_source(source, args_width, "canonical Script args");
            }
            if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &code_hash) {
                self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                return Ok(());
            }
            self.emit_operand_to_register("a1", &args[1]);
            if let Some(source) = &script_args {
                if !self.emit_fixed_byte_source_pointer_or_const_to("a2", source) {
                    self.emit_fail(CellScriptRuntimeError::ScriptConstructionInvalid);
                    return Ok(());
                }
            } else {
                self.emit("li a2, 0");
            }
            self.emit(format!("li a3, {}", args_width));
            self.emit_sp_addi("a4", dest_offset);
            self.emit("call __ckb_script_hash");
            let ok = self.fresh_label("script_hash_ok");
            self.emit(format!("beqz a0, {}", ok));
            self.emit_process_failure_status();
            self.emit_label(&ok);
            self.emit_sp_addi("t0", dest_offset);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
            return Ok(());
        }
        if matches!(helper, RuntimeHelper::CkbHashPair | RuntimeHelper::CkbHashSha256Pair | RuntimeHelper::CkbHashSha256dPair) {
            if args.len() != 2 {
                self.emit("# cellscript abi: fail closed because hash_pair needs two inputs");
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            }
            let Some(left) = self.expected_fixed_byte_source(&args[0], 32) else {
                self.emit("# cellscript abi: fail closed because hash_pair left input is not a 32-byte value");
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            };
            let Some(right) = self.expected_fixed_byte_source(&args[1], 32) else {
                self.emit("# cellscript abi: fail closed because hash_pair right input is not a 32-byte value");
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            };
            self.emit_prepare_fixed_byte_source(&left, 32, "pair hash left input");
            self.emit_prepare_fixed_byte_source(&right, 32, "pair hash right input");
            if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &left) {
                self.emit("# cellscript abi: fail closed because hash_pair left pointer is not materializable");
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            }
            if !self.emit_fixed_byte_source_pointer_or_const_to("a1", &right) {
                self.emit("# cellscript abi: fail closed because hash_pair right pointer is not materializable");
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            }
            self.emit_sp_addi("a2", dest_offset);
            self.emit(format!("call {}", func));
            self.emit_return_on_syscall_error(CellScriptRuntimeError::SyscallFailed);
            self.emit_sp_addi("t0", dest_offset);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
            return Ok(());
        }
        if helper == RuntimeHelper::CkbHashBlake2bPacked {
            let Some(arg) = args.first() else {
                self.emit("# cellscript abi: fail closed because hash_blake2b_packed is missing input");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            let Some(width) = operand_fixed_byte_width(arg).or_else(|| match arg {
                IrOperand::Var(var) => self.fixed_byte_like_width(&var.ty),
                _ => None,
            }) else {
                self.emit("# cellscript abi: fail closed because hash_blake2b_packed input has no static packed width");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            let Some(source) = self.expected_fixed_byte_source(arg, width) else {
                self.emit("# cellscript abi: fail closed because hash_blake2b_packed input is not materializable");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            let type_name = if let IrType::Commitment(inner) = &dest.ty {
                inner.source_text()
            } else {
                match arg {
                    IrOperand::Var(var) => {
                        named_type_name(&var.ty).map(str::to_string).unwrap_or_else(|| aggregate_type_label(&var.ty))
                    }
                    IrOperand::Const(_) => "const".to_string(),
                }
            };
            let mut header = b"CellScriptPackedHashV0\0".to_vec();
            header.extend_from_slice(type_name.as_bytes());
            header.push(0);
            header.extend_from_slice(&(width as u32).to_le_bytes());
            let total_width = header.len() + width;
            if total_width > RUNTIME_SCRATCH_BUFFER_SIZE {
                self.emit("# cellscript abi: fail closed because hash_blake2b_packed preimage exceeds scratch buffer");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            }
            let buffer_offset = self.runtime_scratch_buffer_offset();
            for (index, byte) in header.iter().enumerate() {
                self.emit(format!("li t0, {}", byte));
                self.emit_stack_store_byte("t0", buffer_offset + index);
            }
            if matches!(&dest.ty, IrType::Commitment(_)) {
                let header_ready = self.fresh_label("commitment_commit_header_ready");
                self.emit_label(&header_ready);
            }
            self.emit_prepare_fixed_byte_source(&source, width, "hash_blake2b_packed input");
            if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &source) {
                self.emit("# cellscript abi: fail closed because hash_blake2b_packed input pointer is not materializable");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            }
            self.emit_sp_addi("a1", buffer_offset + header.len());
            self.emit(format!("li a2, {}", width));
            self.emit("call __cellscript_memcpy_fixed");
            self.emit_sp_addi("a0", buffer_offset);
            self.emit(format!("li a1, {}", total_width));
            self.emit_sp_addi("a2", dest_offset);
            self.emit("call __ckb_hash_blake2b_var");
            self.emit_return_on_syscall_error(CellScriptRuntimeError::SyscallFailed);
            self.emit_sp_addi("t0", dest_offset);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
            return Ok(());
        }
        if helper == RuntimeHelper::CkbHashDataPacked {
            let Some(arg) = args.first() else {
                self.emit("# cellscript abi: fail closed because hash_data_packed is missing input");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            let Some(width) = operand_fixed_byte_width(arg).or_else(|| match arg {
                IrOperand::Var(var) => self.fixed_byte_like_width(&var.ty),
                _ => None,
            }) else {
                self.emit("# cellscript abi: fail closed because hash_data_packed input has no static packed width");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            let Some(source) = self.expected_fixed_byte_source(arg, width) else {
                self.emit("# cellscript abi: fail closed because hash_data_packed input is not materializable");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            };
            self.emit_prepare_fixed_byte_source(&source, width, "hash_data_packed input");
            if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &source) {
                self.emit("# cellscript abi: fail closed because hash_data_packed input pointer is not materializable");
                self.emit_fail(CellScriptRuntimeError::PackedHashPreimageMaterializationUnresolved);
                return Ok(());
            }
            self.emit(format!("li a1, {}", width));
            self.emit_sp_addi("a2", dest_offset);
            self.emit("call __ckb_hash_blake2b_var");
            self.emit_return_on_syscall_error(CellScriptRuntimeError::SyscallFailed);
            self.emit_sp_addi("t0", dest_offset);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
            return Ok(());
        }
        let Some(arg) = args.first() else {
            self.emit("# cellscript abi: fail closed because hash helper is missing input");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(source) = self.expected_fixed_byte_source(arg, 32) else {
            self.emit("# cellscript abi: fail closed because hash helper input is not a 32-byte value");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&source, 32, "fixed hash input");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &source) {
            self.emit("# cellscript abi: fail closed because hash helper input pointer is not materializable");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        self.emit_sp_addi("a1", dest_offset);
        self.emit(format!("call {}", func));
        self.emit_return_on_syscall_error(CellScriptRuntimeError::SyscallFailed);
        self.emit_sp_addi("t0", dest_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    pub(super) fn emit_call(&mut self, dest: Option<&IrVar>, target: &IrCallTarget, args: &[IrOperand]) -> Result<()> {
        match target {
            IrCallTarget::Function(symbol) => self.emit_abi_call(dest, symbol, None, args),
            IrCallTarget::Runtime(helper) => self.emit_runtime_call(dest, *helper, args),
            IrCallTarget::InvalidRuntime(symbol) => Err(invalid_runtime_call(symbol)),
        }
    }

    fn emit_runtime_call(&mut self, dest: Option<&IrVar>, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        match helper.availability() {
            RuntimeAvailability::Deferred(feature) => {
                self.emit(format!("# cellscript deferred runtime contract: {}", feature.feature()));
                let failure = helper.failure().ok_or_else(|| invalid_runtime_call(func))?;
                let failure = CellScriptRuntimeError::from_code(failure.code).ok_or_else(|| invalid_runtime_call(func))?;
                self.emit_process_failure(failure);
                return Ok(());
            }
            RuntimeAvailability::Fails(_) => {
                self.emit(format!("# cellscript bounded collection: {} has no executable source-selection/codec/correspondence contract; fail closed", func));
                let failure = helper.failure().ok_or_else(|| invalid_runtime_call(func))?;
                let failure = CellScriptRuntimeError::from_code(failure.code).ok_or_else(|| invalid_runtime_call(func))?;
                self.emit_fail(failure);
                return Ok(());
            }
            RuntimeAvailability::Implemented => {}
        }
        // No wildcard: registering another helper requires an explicit caller
        // lowering choice as well as its independent runtime-body inventory.
        match helper {
            RuntimeHelper::CkbCommitmentOpen => self.emit_commitment_open_call(dest, args),
            RuntimeHelper::CkbHashBlake2b
            | RuntimeHelper::CkbHashBlake2bPacked
            | RuntimeHelper::CkbHashBlake2bVar
            | RuntimeHelper::CkbHashChain
            | RuntimeHelper::CkbHashDataPacked
            | RuntimeHelper::CkbHashPair
            | RuntimeHelper::CkbHashSha256
            | RuntimeHelper::CkbHashSha256Pair
            | RuntimeHelper::CkbHashSha256d
            | RuntimeHelper::CkbHashSha256dPair
            | RuntimeHelper::CkbScriptHash => self.emit_ckb_fixed_hash_call(dest, helper, args),
            RuntimeHelper::CkbSourceBytesEqualMemory => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_source_memory_equality_call(dest, args)
            }
            RuntimeHelper::CkbCurrentScriptHash | RuntimeHelper::CkbTransactionHash => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_current_script_hash_call(dest, helper, args)
            }
            RuntimeHelper::CkbSighashAllZeroLock => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_sighash_all_zero_lock_call(dest, helper, args)
            }
            RuntimeHelper::CkbInputOutPointTxHash => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_input_out_point_tx_hash_call(dest, helper, args)
            }
            RuntimeHelper::CkbCellDataHashField
            | RuntimeHelper::CkbCellLockArgs32
            | RuntimeHelper::CkbCellLockCodeHash
            | RuntimeHelper::CkbCellLockHash
            | RuntimeHelper::CkbCellTypeArgs32
            | RuntimeHelper::CkbCellTypeCodeHash
            | RuntimeHelper::CkbCellTypeHash => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_cell_script_hash_field_call(dest, helper, args)
            }
            RuntimeHelper::CkbCellDataBytes32 => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_cell_data_bytes32_call(dest, helper, args)
            }
            RuntimeHelper::CkbCellDataBlake2bSpan
            | RuntimeHelper::CkbRawTransactionHashWithoutCellDeps
            | RuntimeHelper::CkbTransactionBlake2bGather
            | RuntimeHelper::CkbWitnessBlake2bSelectChunks
            | RuntimeHelper::CkbWitnessBlake2bSpan
            | RuntimeHelper::CkbWitnessBoundedBlake2b
            | RuntimeHelper::CkbWitnessBytes32 => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_span_hash_call(dest, helper, args)
            }
            RuntimeHelper::CkbWitnessInputTypeExact32
            | RuntimeHelper::CkbWitnessLockExact32
            | RuntimeHelper::CkbWitnessOutputTypeExact32 => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_witness_hash_call(dest, helper, args)
            }
            RuntimeHelper::CkbRequireCellDataHash
            | RuntimeHelper::CkbRequireCellLockArgs32
            | RuntimeHelper::CkbRequireCellLockArgsPrefix32
            | RuntimeHelper::CkbRequireCellLockArgsSuffix32
            | RuntimeHelper::CkbRequireCellLockHash
            | RuntimeHelper::CkbRequireCellTypeArgs32
            | RuntimeHelper::CkbRequireCellTypeArgsPrefix32
            | RuntimeHelper::CkbRequireCellTypeArgsSuffix32
            | RuntimeHelper::CkbRequireCellTypeHash
            | RuntimeHelper::CkbRequireInputOutPointTxHash
            | RuntimeHelper::XudtRequireOwnerModeInputType => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_fixed_hash_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireCellDepExactVerifierHandle
            | RuntimeHelper::CkbRequireCellLockExactHandle
            | RuntimeHelper::CkbRequireCellTypeExactHandle => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_exact_script_handle_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireCellDepOpenScriptHandle
            | RuntimeHelper::CkbRequireCellDepOpenScriptHandleFromArgs
            | RuntimeHelper::CkbRequireCellDepOpenVerifierHandle
            | RuntimeHelper::CkbRequireCellDepOpenVerifierHandleFromArgs
            | RuntimeHelper::CkbRequireInstanceScriptParticipantFromArgs
            | RuntimeHelper::CkbRequireOpenScriptParticipantFromArgs => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_open_handle_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireCellDepDeploymentLineVerifierHandle
            | RuntimeHelper::CkbRequireCellLockDeploymentLineHandle
            | RuntimeHelper::CkbRequireCellTypeDeploymentLineHandle => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_deployment_line_handle_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireBoundedCellDepDataHash => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_bounded_cell_dep_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireSha256dMerkleRoot => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_sha256d_merkle_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireCellLockScriptHashType | RuntimeHelper::CkbRequireCellTypeScriptHashType => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_cell_script_hash_type_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireCellLockArgsExact | RuntimeHelper::CkbRequireCellTypeArgsExact => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_cell_script_args_exact_requirement_call(helper, args)
            }
            RuntimeHelper::CkbRequireInputOutPoint => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_input_out_point_requirement_call(helper, args)
            }
            RuntimeHelper::XudtRequireOwnerModeTypeArgs => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_xudt_type_args_requirement_call(helper, args)
            }
            RuntimeHelper::XudtRequireGroupAmountBurned | RuntimeHelper::XudtRequireGroupAmountMinted => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_xudt_group_amount_delta_call(helper, args)
            }
            RuntimeHelper::CkbRequireLockTypeMetapointPairsFromI32DataFiltered
            | RuntimeHelper::CkbRequireTypeLockMetapointPairsFromI32DataFiltered => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_metapoint_filtered_pair_call(helper, args)
            }
            RuntimeHelper::C256RequireU128ProductEq | RuntimeHelper::C256RequireU128ProductLte => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_c256_product_requirement_call(helper, args)
            }
            RuntimeHelper::C256RequireU128Sum2ProductsEq | RuntimeHelper::C256RequireU128Sum2ProductsLte => {
                self.emit(format!("# call {}", func));
                self.emit_runtime_c256_sum2_product_requirement_call(helper, args)
            }
            RuntimeHelper::ZkRequireTransition => self.emit_zk_transition(args),
            RuntimeHelper::Bip340RequireSignature => self.emit_bip340_verifier_call(helper, args),
            RuntimeHelper::Bip340RequireSignatureFromCellDep => self.emit_bip340_verifier_call(helper, args),
            RuntimeHelper::CkbExecCellDepHex4 => {
                self.emit(format!("# call {}", func));
                self.emit_hex4_transport_call(helper, args)
            }
            RuntimeHelper::CkbSpawnWaitCellDepHex4 => {
                self.emit(format!("# call {}", func));
                self.emit_hex4_transport_call(helper, args)
            }
            RuntimeHelper::CkbExecCellDepU8Args
            | RuntimeHelper::CkbTransactionU32Le
            | RuntimeHelper::CkbCurrentRole
            | RuntimeHelper::CkbSinceToRaw
            | RuntimeHelper::CkbEpochNumberToU64
            | RuntimeHelper::CkbEpochDurationToU64
            | RuntimeHelper::CkbBlockNumberToU64
            | RuntimeHelper::CkbEpochLengthToU64
            | RuntimeHelper::CkbTimestampMillisToU64
            | RuntimeHelper::CkbCellCapacity
            | RuntimeHelper::CkbCellOccupiedCapacity
            | RuntimeHelper::CkbCellUnoccupiedCapacity
            | RuntimeHelper::CkbCellOutputIndex
            | RuntimeHelper::CkbInputOutPointIndex
            | RuntimeHelper::CkbInputOutPointTxHashLow
            | RuntimeHelper::CkbRequireMetapointRelative
            | RuntimeHelper::CkbRequireLockTypeMetapointPairs
            | RuntimeHelper::CkbRequireTypeLockMetapointPairs
            | RuntimeHelper::CkbRequireLockTypeMetapointPairsFromI32Data
            | RuntimeHelper::CkbRequireTypeLockMetapointPairsFromI32Data
            | RuntimeHelper::CkbRequireLockMatchMasterOutPointPairsFromData
            | RuntimeHelper::CkbCellLockHashLow
            | RuntimeHelper::CkbCellTypeHashLow
            | RuntimeHelper::CkbCellLockHashType
            | RuntimeHelper::CkbCellTypeHashType
            | RuntimeHelper::CkbCellLockArgsEmpty
            | RuntimeHelper::CkbCellTypeArgsEmpty
            | RuntimeHelper::CkbRequireCurrentScriptArgsEmpty
            | RuntimeHelper::CkbRequireCellLockArgsEmpty
            | RuntimeHelper::CkbRequireCellTypeArgsEmpty
            | RuntimeHelper::CkbCellDataSize
            | RuntimeHelper::CkbCellDataEqual
            | RuntimeHelper::CkbSourceBytesEqual
            | RuntimeHelper::CkbSourceBytesZero
            | RuntimeHelper::CkbCellCount
            | RuntimeHelper::CkbCellHasType
            | RuntimeHelper::CkbCellDataU32Le
            | RuntimeHelper::CkbCellDataU64Le
            | RuntimeHelper::DaoAccumulatedRate
            | RuntimeHelper::DaoInputAccumulatedRate
            | RuntimeHelper::DaoHasDaoType
            | RuntimeHelper::DaoIsDepositData
            | RuntimeHelper::DaoIsWithdrawalRequestData
            | RuntimeHelper::DaoRequireHeaderDepForInput
            | RuntimeHelper::DaoRequireInputSinceAtLeast
            | RuntimeHelper::DaoRequireInputRelativeEpochSinceAtLeast
            | RuntimeHelper::XudtAmountLow
            | RuntimeHelper::XudtAmountHigh
            | RuntimeHelper::XudtOwnerModeInputTypeHash
            | RuntimeHelper::XudtRequireOwnerModeTypeArgsCurrentScript
            | RuntimeHelper::CellscriptRequireFungibleTypeGroupV1
            | RuntimeHelper::XudtRequireGroupAmountConserved
            | RuntimeHelper::CkbWitnessBoundedSize
            | RuntimeHelper::CkbWitnessBoundedU8
            | RuntimeHelper::CkbWitnessBoundedU32Le
            | RuntimeHelper::CkbWitnessBoundedU64Le
            | RuntimeHelper::CkbWitnessSize
            | RuntimeHelper::CkbWitnessCount
            | RuntimeHelper::CkbWitnessU8
            | RuntimeHelper::CkbWitnessU32Le
            | RuntimeHelper::CkbWitnessU64Le
            | RuntimeHelper::CkbCellDataU8
            | RuntimeHelper::CkbCellLockSize
            | RuntimeHelper::CkbCellTypeSize
            | RuntimeHelper::CkbCellLockU8
            | RuntimeHelper::CkbCellTypeU8
            | RuntimeHelper::CkbInputSinceAt
            | RuntimeHelper::CkbRequireWitnessSizeAtLeast
            | RuntimeHelper::CkbSighashAll
            | RuntimeHelper::CkbRequireMaturity
            | RuntimeHelper::CkbRequireTime
            | RuntimeHelper::CkbRequireEpochAfter
            | RuntimeHelper::CkbRequireEpochRelative
            | RuntimeHelper::CkbOccupiedCapacity
            | RuntimeHelper::CellscriptAbort
            | RuntimeHelper::CellscriptBlake2bCompress
            | RuntimeHelper::CellscriptMulU128ToU256
            | RuntimeHelper::CellscriptLoadU64Le
            | RuntimeHelper::CellscriptMemcmpFixed
            | RuntimeHelper::CellscriptMemzeroFixed
            | RuntimeHelper::CellscriptAddU256
            | RuntimeHelper::CellscriptExactReadCached
            | RuntimeHelper::EnvCurrentTimepoint
            | RuntimeHelper::CkbInputSince
            | RuntimeHelper::CkbHeaderEpochNumber
            | RuntimeHelper::CkbHeaderEpochStartBlockNumber
            | RuntimeHelper::CkbHeaderEpochLength
            | RuntimeHelper::CkbHeaderDepEpochNumber
            | RuntimeHelper::CkbHeaderDepEpochStartBlockNumber
            | RuntimeHelper::CkbHeaderDepEpochLength
            | RuntimeHelper::CkbHeaderDepBlockNumber
            | RuntimeHelper::CkbHeaderDepTimestampMillis
            | RuntimeHelper::CellscriptCurrentScriptRoleAt
            | RuntimeHelper::CellscriptRequireCellMembership
            | RuntimeHelper::CellscriptRequireExactSize
            | RuntimeHelper::CellscriptRequireMinSize
            | RuntimeHelper::CellscriptMemcpyFixed
            | RuntimeHelper::CellscriptSha256Compress
            | RuntimeHelper::CellscriptSha256Fixed
            | RuntimeHelper::CellscriptBlake2bPrefixedTransactionSpan
            | RuntimeHelper::CellscriptBlake2bSegments
            | RuntimeHelper::CellscriptBlake2bTransactionSpan
            | RuntimeHelper::CkbSpawnWithFd1
            | RuntimeHelper::CellscriptWitnessBoundedResolve
            | RuntimeHelper::CkbEpochAdd
            | RuntimeHelper::CkbEpochDuration
            | RuntimeHelper::CkbEpochSub
            | RuntimeHelper::CkbSinceAsAbsoluteBlock
            | RuntimeHelper::CkbSinceAsAbsoluteEpoch
            | RuntimeHelper::CkbSinceAsAbsoluteTimestamp
            | RuntimeHelper::CkbSinceAsRelativeBlock
            | RuntimeHelper::CkbSinceAsRelativeEpoch
            | RuntimeHelper::CkbSinceAsRelativeTimestamp
            | RuntimeHelper::CkbSinceBlockAbsolute
            | RuntimeHelper::CkbSinceBlockRelative
            | RuntimeHelper::CkbSinceDecode
            | RuntimeHelper::CkbSinceEpochAbsolute
            | RuntimeHelper::CkbSinceEpochRelative
            | RuntimeHelper::CkbSinceFromRawChecked
            | RuntimeHelper::CkbSinceIsDisabled
            | RuntimeHelper::CkbSinceIsRelative
            | RuntimeHelper::CkbSinceMetric
            | RuntimeHelper::CkbSinceTimestampAbsolute
            | RuntimeHelper::CkbSinceTimestampRelative
            | RuntimeHelper::CkbSinceValue
            | RuntimeHelper::CkbSourceCellDep
            | RuntimeHelper::CkbSourceGroupInput
            | RuntimeHelper::CkbSourceGroupOutput
            | RuntimeHelper::CkbSourceHeaderDep
            | RuntimeHelper::CkbSourceInput
            | RuntimeHelper::CkbSourceOutput
            | RuntimeHelper::CkbWait
            | RuntimeHelper::CkbProcessId
            | RuntimeHelper::CkbPipe
            | RuntimeHelper::CkbPipeWrite
            | RuntimeHelper::CkbPipeRead
            | RuntimeHelper::CkbInheritedFd
            | RuntimeHelper::CkbClose
            | RuntimeHelper::BoundedConsumeEachFailClosed
            | RuntimeHelper::BoundedCreateEachFailClosed => self.emit_abi_call(dest, func, Some(helper), args),
        }
    }

    fn emit_bip340_verifier_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        self.emit(format!("# call {} args={}", func, args.len()));
        let explicit_dep = helper == RuntimeHelper::Bip340RequireSignatureFromCellDep;
        let value_offset = usize::from(explicit_dep);
        if args.len() != 3 + value_offset {
            self.emit("# cellscript abi: fail closed because BIP340 verifier requires message, pubkey, signature");
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        }
        let Some(message) = self.expected_fixed_byte_source(&args[value_offset], 32) else {
            self.emit("# cellscript abi: fail closed because BIP340 message is not a 32-byte value");
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        };
        let Some(pubkey) = self.expected_fixed_byte_source(&args[value_offset + 1], 32) else {
            self.emit("# cellscript abi: fail closed because BIP340 pubkey is not a 32-byte value");
            self.emit_fail(CellScriptRuntimeError::Bip340PubkeyMaterializationUnresolved);
            return Ok(());
        };
        let Some(signature) = self.expected_fixed_byte_source(&args[value_offset + 2], 64) else {
            self.emit("# cellscript abi: fail closed because BIP340 signature is not a 64-byte value");
            self.emit_fail(CellScriptRuntimeError::Bip340SignatureMaterializationUnresolved);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&message, 32, "novaseal bip340 message");
        self.emit_prepare_fixed_byte_source(&pubkey, 32, "novaseal bip340 pubkey");
        self.emit_prepare_fixed_byte_source(&signature, 64, "novaseal bip340 signature");
        let Some(read_fd_offset) = self.checked_runtime_expr_temp_offset(0) else {
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        };
        let Some(write_fd_offset) = self.checked_runtime_expr_temp_offset(1) else {
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        };
        let Some(child_pid_offset) = self.checked_runtime_expr_temp_offset(2) else {
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        };
        let ipc_buffer_offset = self.runtime_scratch_buffer_offset();
        self.emit("# cellscript abi: NovaSeal BIP340 verifier IPC envelope via VM2 pipe/spawn/wait");
        let pipe_ok = self.fresh_label("novaseal_bip340_pipe_ok");
        self.emit("call __ckb_pipe");
        self.emit(format!("beqz a0, {}", pipe_ok));
        self.emit_fail(CellScriptRuntimeError::Bip340PipeCreateFailed);
        self.emit_label(&pipe_ok);
        self.emit_stack_store("a1", read_fd_offset);
        self.emit_stack_store("a2", write_fd_offset);
        self.emit("# cellscript abi: materialize cellscript-btc-bip340-ipc-v0 envelope in scratch");
        for (index, byte) in b"NSBV0IPC".iter().enumerate() {
            self.emit(format!("li t0, {}", byte));
            self.emit_stack_store_byte("t0", ipc_buffer_offset + index);
        }
        for (index, byte) in [0u8, 0, 1, 0, 0, 0, 0, 0].iter().enumerate() {
            self.emit(format!("li t0, {}", byte));
            self.emit_stack_store_byte("t0", ipc_buffer_offset + 8 + index);
        }
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &message) {
            self.emit_fail(CellScriptRuntimeError::Bip340MessageMaterializationUnresolved);
            return Ok(());
        }
        self.emit_sp_addi("a1", ipc_buffer_offset + 16);
        self.emit("li a2, 32");
        self.emit("call __cellscript_memcpy_fixed");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &pubkey) {
            self.emit_fail(CellScriptRuntimeError::Bip340PubkeyMaterializationUnresolved);
            return Ok(());
        }
        self.emit_sp_addi("a1", ipc_buffer_offset + 48);
        self.emit("li a2, 32");
        self.emit("call __cellscript_memcpy_fixed");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &signature) {
            self.emit_fail(CellScriptRuntimeError::Bip340SignatureMaterializationUnresolved);
            return Ok(());
        }
        self.emit_sp_addi("a1", ipc_buffer_offset + 80);
        self.emit("li a2, 64");
        self.emit("call __cellscript_memcpy_fixed");
        self.emit("# cellscript abi: spawn manifest-bound verifier CellDep with prepared read fd inherited");
        if explicit_dep {
            self.emit_operand_to_register("a0", &args[0]);
        } else {
            self.emit("li a0, 0");
        }
        self.emit_stack_load("a1", read_fd_offset);
        self.emit("call __ckb_spawn_with_fd1");
        let spawn_ok = self.fresh_label("novaseal_bip340_spawn_ok");
        self.emit(format!("beqz a0, {}", spawn_ok));
        self.emit_fail(CellScriptRuntimeError::Bip340SpawnFailed);
        self.emit_label(&spawn_ok);
        self.emit_stack_store("a1", child_pid_offset);
        self.emit("# cellscript abi: BIP340 IPC write canonical 18-word little-endian envelope");
        for word_index in 0..18 {
            self.emit(format!("# cellscript abi: novaseal bip340 ipc word {}", word_index));
            self.emit_stack_load("a0", write_fd_offset);
            self.emit_stack_load("a1", ipc_buffer_offset + word_index * 8);
            self.emit("call __ckb_pipe_write");
            let write_ok = self.fresh_label("novaseal_bip340_write_ok");
            self.emit(format!("beqz a0, {}", write_ok));
            self.emit_fail(CellScriptRuntimeError::Bip340MessageWriteFailed);
            self.emit_label(&write_ok);
        }
        self.emit_stack_load("a0", write_fd_offset);
        self.emit("call __ckb_close");
        let close_ok = self.fresh_label("novaseal_bip340_close_ok");
        self.emit(format!("beqz a0, {}", close_ok));
        self.emit_fail(CellScriptRuntimeError::Bip340VerifierReadFailed);
        self.emit_label(&close_ok);
        self.emit_stack_load("a0", child_pid_offset);
        self.emit("call __ckb_wait");
        let wait_ok = self.fresh_label("novaseal_bip340_wait_ok");
        self.emit(format!("beqz a0, {}", wait_ok));
        self.emit_fail(CellScriptRuntimeError::Bip340ChildRejected);
        self.emit_label(&wait_ok);
        Ok(())
    }

    fn emit_hex4_transport_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        let Some(IrOperand::Var(bytes)) = args.get(1) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        if args.len() != 6 || bytes.ty != IrType::vector(IrType::U8) || !self.stack_collection_vars.contains(&bytes.id) {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        self.emit_operand_to_register("a0", &args[0]);
        self.emit_operand_to_register("a1", &args[1]);
        self.emit_load(LoadOp::Double, "a2", "a1", -8); // proven local byte-vector count
        for (arg, register) in args[2..].iter().zip(["a3", "a4", "a5", "a6"]) {
            self.emit_operand_to_register(register, arg);
        }
        self.emit(format!("call {func}"));
        let ok = self.fresh_label("hex4_checked_return");
        self.emit(format!("beqz a0, {ok}"));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        Ok(())
    }

    fn emit_abi_call(
        &mut self,
        dest: Option<&IrVar>,
        func: &str,
        runtime_helper: Option<RuntimeHelper>,
        args: &[IrOperand],
    ) -> Result<()> {
        if func.contains("::") {
            return Err(CompileError::new(
                format!("qualified function call '{}' reached codegen without IR label normalization; this is a compiler bug", func),
                crate::error::Span::default(),
            ));
        }
        self.emit(format!("# call {}", func));

        let abi = runtime_helper.is_none().then(|| self.callable_abis.get(func).cloned()).flatten();
        let return_buffer_bytes = abi.as_ref().and_then(|abi| abi.return_buffer_bytes);
        let outgoing_stack_arg_bytes = align_stack_arg_bytes(
            (call_abi_arg_count(abi.as_ref(), args) + usize::from(return_buffer_bytes.is_some())).saturating_sub(8) * 8,
        );
        let mut abi_index = 0usize;
        let scalar_call = abi
            .as_ref()
            .filter(|abi| {
                abi.checked_scalar_parameters
                    && abi.params.iter().any(|param| {
                        matches!(param.ty, IrType::Bool | IrType::U8 | IrType::U16 | IrType::U32 | IrType::I32 | IrType::U64)
                    })
            })
            .map(|_| self.fresh_label("allocated_call"));
        for (arg_index, arg) in args.iter().enumerate() {
            if let Some(abi) = &abi
                && let Some(param) = abi.params.get(arg_index)
            {
                let needs_type_hash = abi.type_hash_param_indices.contains(&arg_index);
                let scalar_marker = scalar_call
                    .as_ref()
                    .filter(|_| matches!(param.ty, IrType::Bool | IrType::U8 | IrType::U16 | IrType::U32 | IrType::I32 | IrType::U64))
                    .map(|marker| format!("{marker}_{arg_index}"));
                if let Some(marker) = &scalar_marker {
                    self.emit_label(&format!("{marker}_begin"));
                }
                if !self.emit_call_param_arg(func, param, needs_type_hash, &mut abi_index, arg, outgoing_stack_arg_bytes) {
                    return Ok(());
                }
                if let Some(marker) = &scalar_marker {
                    self.emit_label(&format!("{marker}_end"));
                }
                continue;
            }
            if !self.emit_call_scalar_arg(func, &format!("arg{}", arg_index), &mut abi_index, arg, outgoing_stack_arg_bytes) {
                return Ok(());
            }
        }

        let mut result_marker = None;
        let return_buffer_offset = if let Some(width) = return_buffer_bytes {
            let dest = dest.ok_or_else(|| CompileError::without_span("fixed struct call has no result storage"))?;
            if self.fixed_struct_return_width(&dest.ty) != Some(width) {
                return Err(CompileError::without_span("fixed struct call result layout differs from the callee ABI"));
            }
            let offset = self
                .fixed_byte_local_offsets
                .get(&dest.id)
                .copied()
                .ok_or_else(|| CompileError::without_span("fixed struct call result buffer is unavailable"))?;
            let register = self.call_abi_register(abi_index);
            let marker = self.fresh_label(&format!(
                "result_v1_call_{}_{}_{}_{}_{}_{}",
                dest.id,
                offset,
                width,
                abi_index,
                outgoing_stack_arg_bytes,
                self.scalar_slot_offset(dest.id)
            ));
            self.emit_label(&marker);
            result_marker = Some(marker);
            self.emit(format!(
                "# cellscript abi: call {func} caller-owned struct result size={width} pointer={}",
                abi_arg_label(abi_index)
            ));
            self.emit_sp_addi(&register, offset);
            self.emit_outgoing_call_stack_arg_store(&register, abi_index, outgoing_stack_arg_bytes);
            Some(offset)
        } else {
            None
        };

        if outgoing_stack_arg_bytes > 0 {
            self.emit(format!("# cellscript abi: reserve {} bytes for outgoing stack call arguments", outgoing_stack_arg_bytes));
            self.emit_large_addi("sp", "sp", -(outgoing_stack_arg_bytes as i64));
        }
        if runtime_helper.is_some_and(is_cached_exact_read_helper) {
            if !self.module_uses_exact_read_cache {
                self.emit_fail(CellScriptRuntimeError::SyscallFailed);
                return Ok(());
            }
            self.emit("mv a2, s11");
        }
        if let Some(marker) = &scalar_call {
            self.emit_label(&format!("{marker}_invoke"));
        }
        self.emit(format!("call {}", func));
        if outgoing_stack_arg_bytes > 0 {
            self.emit_large_addi("sp", "sp", outgoing_stack_arg_bytes as i64);
        }
        if let Some(marker) = &result_marker {
            self.emit_label(&format!("{marker}_end"));
        }

        // Exact cached reads terminate inside their shared runtime helper on
        // any invalid source or syscall failure. Successful calls therefore
        // return only the scalar value in a0 and need no per-call status
        // branch. Other scalar runtime helpers retain the a1 status ABI.
        if runtime_helper.map(RuntimeHelper::return_abi) == Some(runtime_contract::RuntimeReturnAbi::ScalarStatusA1) {
            let ok_label = self.fresh_label("runtime_scalar_ok");
            self.emit("# cellscript abi: scalar runtime helper status check (a1 == 0)");
            self.emit(format!("beqz a1, {}", ok_label));
            self.emit_add_immediate("a0", "a1", 0);
            self.emit_process_failure_status();
            self.emit_label(&ok_label);
        }

        if runtime_helper.map(RuntimeHelper::return_abi) == Some(runtime_contract::RuntimeReturnAbi::StatusA0) {
            let ok_label = self.fresh_label("runtime_requirement_ok");
            self.emit(format!("beqz a0, {}", ok_label));
            self.emit_process_failure_status();
            self.emit_label(&ok_label);
        }

        if runtime_helper.map(RuntimeHelper::return_abi) == Some(runtime_contract::RuntimeReturnAbi::StatusA0ValuesA1A2) {
            let ok_label = self.fresh_label("runtime_pair_ok");
            self.emit("# cellscript abi: consume status a0, then receive pair from a1/a2");
            self.emit(format!("beqz a0, {}", ok_label));
            self.emit_process_failure_status();
            self.emit_label(&ok_label);
            self.emit("mv a0, a1");
            self.emit("mv a1, a2");
        }

        if let Some(d) = dest {
            if let Some(offset) = return_buffer_offset {
                let marker = result_marker.as_ref().expect("fixed result call has a machine marker");
                self.emit_label(&format!("{marker}_receive"));
                self.emit_sp_addi("t0", offset);
                self.emit_stack_store("t0", self.scalar_slot_offset(d.id));
                self.emit_label(&format!("{marker}_received"));
                return Ok(());
            }
            let payload_enum = match &d.ty {
                IrType::Named(name) => {
                    self.enum_layouts.get(name).filter(|layout| layout.has_payload()).map(|layout| (name.clone(), layout.clone()))
                }
                _ => None,
            };
            if let Some((name, layout)) = payload_enum {
                if let Some(offset) = self.fixed_byte_local_offsets.get(&d.id).copied() {
                    self.emit(format!(
                        "# cellscript abi: receive payload enum {} size={} from a0/a1 register pair",
                        name, layout.encoded_size
                    ));
                    let low_width = layout.encoded_size.min(8);
                    for byte_index in 0..low_width {
                        self.emit_stack_store_byte("a0", offset + byte_index);
                        if byte_index + 1 < low_width {
                            self.emit("srli a0, a0, 8");
                        }
                    }
                    if layout.encoded_size > 8 {
                        let high_width = layout.encoded_size - 8;
                        for byte_index in 0..high_width {
                            self.emit_stack_store_byte("a1", offset + 8 + byte_index);
                            if byte_index + 1 < high_width {
                                self.emit("srli a1, a1, 8");
                            }
                        }
                    }
                    self.emit_sp_addi("t0", offset);
                    self.emit_stack_store("t0", self.scalar_slot_offset(d.id));
                } else {
                    self.emit("# cellscript abi: payload enum call destination has no storage; fail closed");
                    self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                }
            } else if d.ty == IrType::U128 {
                if let Some(offset) = self.u128_value_offsets.get(&d.id).copied() {
                    self.emit("# cellscript abi: receive u128 return from a0(low)/a1(high)");
                    self.emit_stack_store("a0", offset);
                    self.emit_stack_store("a1", offset + 8);
                    self.emit_store_u128_pointer_for_var(d.id, offset);
                } else {
                    self.emit("# cellscript abi: u128 call destination has no storage; fail closed");
                    self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                }
            } else if let IrType::Tuple(items) = &d.ty {
                if self.emit_fixed_tuple_call_result(d) {
                    return Ok(());
                }
                self.emit_stack_store("a0", self.scalar_slot_offset(d.id));
                for (index, item) in items.iter().take(8).enumerate() {
                    let field = index.to_string();
                    if let Some(field_var_id) = self.tuple_call_return_field_slots.get(&(d.id, field)).copied() {
                        if let IrType::Array(inner, width) = item
                            && **inner == IrType::U8
                            && (1..=8).contains(width)
                            && let Some(offset) = self.fixed_byte_local_offsets.get(&field_var_id).copied()
                        {
                            // Tuple return registers carry packed short arrays;
                            // field projections carry addressed bytes. Convert
                            // at the call, before conditional/repeated reads.
                            self.emit(format!("mv t0, a{index}"));
                            for byte in 0..*width {
                                self.emit_stack_store_byte("t0", offset + byte);
                                if byte + 1 < *width {
                                    self.emit("srli t0, t0, 8");
                                }
                            }
                            self.emit_sp_addi("t0", offset);
                            self.emit_stack_store("t0", self.scalar_slot_offset(field_var_id));
                        } else {
                            self.emit_stack_store(&format!("a{}", index), self.scalar_slot_offset(field_var_id));
                        }
                    }
                }
            } else {
                self.emit_stack_store("a0", self.scalar_slot_offset(d.id));
            }
        }

        Ok(())
    }

    fn emit_runtime_source_memory_equality_call(&mut self, dest: Option<&IrVar>, args: &[IrOperand]) -> Result<()> {
        let Some(dest) = dest else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let [view, base, memory, length, kind] = args else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        if dest.ty != IrType::Bool {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        let Some(width) = (match memory {
            IrOperand::Var(var) => self.fixed_byte_like_width(&var.ty),
            IrOperand::Const(_) => operand_fixed_byte_width(memory),
        }) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(source) = self.expected_fixed_byte_source(memory, width) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&source, width, "source byte-range memory operand");
        self.emit_operand_to_register("a0", view);
        self.emit_operand_to_register("a1", base);
        if !self.emit_fixed_byte_source_pointer_or_const_to("a2", &source) {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        self.emit_operand_to_register("a3", length);
        self.emit_operand_to_register("a4", kind);
        self.emit("call __ckb_source_bytes_equal_memory");
        let ok = self.fresh_label("source_memory_equal_status_ok");
        self.emit("# cellscript abi: source-memory equality status check (a1 == 0)");
        self.emit(format!("beqz a1, {ok}"));
        self.emit_add_immediate("a0", "a1", 0);
        self.emit_process_failure_status();
        self.emit_label(&ok);
        self.emit_stack_store("a0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_current_script_hash_call(
        &mut self,
        dest: Option<&IrVar>,
        helper: RuntimeHelper,
        args: &[IrOperand],
    ) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        if !args.is_empty() || dest.ty != IrType::Hash {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: current script hash destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: current script hash destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        let (description, helper, label_prefix) = if helper == RuntimeHelper::CkbTransactionHash {
            ("transaction hash", "__ckb_transaction_hash", "transaction_hash")
        } else {
            ("current script hash", "__ckb_current_script_hash", "current_script_hash")
        };
        self.emit(format!("# cellscript abi: load {description} into addressable Hash"));
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        self.emit_sp_addi("a0", buffer_offset);
        self.emit_sp_addi("a1", size_offset);
        self.emit(format!("call {helper}"));
        let ok_label = self.fresh_label(&format!("{label_prefix}_ok"));
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_sighash_all_zero_lock_call(
        &mut self,
        dest: Option<&IrVar>,
        helper: RuntimeHelper,
        args: &[IrOperand],
    ) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        if args.len() != 4 || !crate::ir::is_ckb_sighash_all_result(helper, &dest.ty) {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: sighash-all destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: sighash-all destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        self.emit("# cellscript abi: canonical bounded CKB sighash-all zero-lock message domain");
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        for (arg, register) in args.iter().zip(["a0", "a1", "a2", "a3"]) {
            self.emit_operand_to_register(register, arg);
        }
        self.emit_sp_addi("a4", buffer_offset);
        self.emit("call __ckb_sighash_all_zero_lock");
        let ok_label = self.fresh_label("sighash_all_zero_lock_ok");
        self.emit(format!("beqz a0, {ok_label}"));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_input_out_point_tx_hash_call(
        &mut self,
        dest: Option<&IrVar>,
        helper: RuntimeHelper,
        args: &[IrOperand],
    ) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        if args.len() != 1 || dest.ty != IrType::Hash {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: input OutPoint tx hash destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: input OutPoint tx hash destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        self.emit("# cellscript abi: load SourceView input OutPoint tx hash into addressable Hash");
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        self.emit_operand_to_register("a0", &args[0]);
        self.emit_sp_addi("a1", buffer_offset);
        self.emit_sp_addi("a2", size_offset);
        self.emit("call __ckb_input_out_point_tx_hash");
        let ok_label = self.fresh_label("input_out_point_tx_hash_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_cell_script_hash_field_call(
        &mut self,
        dest: Option<&IrVar>,
        helper: RuntimeHelper,
        args: &[IrOperand],
    ) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        let raw_args = matches!(helper, RuntimeHelper::CkbCellLockArgs32 | RuntimeHelper::CkbCellTypeArgs32);
        let valid_result = if raw_args {
            crate::ir::is_raw_bytes32_runtime_result(helper, &dest.ty)
        } else {
            dest.ty == IrType::Hash || crate::ir::is_ckb_script_hash_property_result(helper, &dest.ty)
        };
        if args.len() != 1 || !valid_result {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: ScriptRef hash destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: ScriptRef hash destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        self.emit("# cellscript abi: load SourceView ScriptRef hash field into addressable Hash");
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        self.emit_operand_to_register("a0", &args[0]);
        self.emit_sp_addi("a1", buffer_offset);
        self.emit_sp_addi("a2", size_offset);
        self.emit(format!("call {}", func));
        let ok_label = self.fresh_label("script_ref_hash_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_cell_data_bytes32_call(&mut self, dest: Option<&IrVar>, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        if args.len() != 2 || !crate::ir::is_raw_bytes32_runtime_result(helper, &dest.ty) {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: cell data bytes32 destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: cell data bytes32 destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        self.emit("# cellscript abi: load 32 raw bytes from SourceView cell data into [u8; 32]");
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        self.emit_operand_to_register("a0", &args[0]);
        self.emit_operand_to_register("a1", &args[1]);
        self.emit_sp_addi("a2", buffer_offset);
        self.emit_sp_addi("a3", size_offset);
        self.emit("call __ckb_cell_data_bytes32");
        let ok_label = self.fresh_label("cell_data_bytes32_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_span_hash_call(&mut self, dest: Option<&IrVar>, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if matches!(helper, RuntimeHelper::CkbTransactionBlake2bGather | RuntimeHelper::CkbWitnessBlake2bSelectChunks) {
            let select = helper == RuntimeHelper::CkbWitnessBlake2bSelectChunks;
            let Some(dest) = dest else {
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            };
            let vector_start = if select { 3 } else { 0 };
            let valid = args.len() == if select { 6 } else { 4 }
                && args.iter().enumerate().skip(vector_start).all(|(index, arg)| {
                    let element = if !select && index < 2 { IrType::U64 } else { IrType::U8 };
                    matches!(arg, IrOperand::Var(var) if var.ty.vector_element() == Some(&element) && self.stack_collection_vars.contains(&var.id))
                });
            let (Some(size), Some(buffer)) =
                (self.cell_buffer_size_offsets.get(&dest.id).copied(), self.cell_buffer_offsets.get(&dest.id).copied())
            else {
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            };
            if !valid || dest.ty != IrType::Hash {
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return Ok(());
            }
            self.emit("li t0, 32");
            self.emit_stack_store("t0", size);
            for (index, arg) in args.iter().enumerate() {
                self.emit_operand_to_register(&format!("a{index}"), arg);
            }
            self.emit_sp_addi(if select { "a6" } else { "a4" }, buffer);
            self.emit(format!("call {func}"));
            let ok = self.fresh_label("gather_hash_ok");
            self.emit(format!("beqz a0, {ok}"));
            self.emit_process_failure_status();
            self.emit_label(&ok);
            self.emit_sp_addi("t0", buffer);
            self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
            return Ok(());
        }
        let raw_transaction = helper == RuntimeHelper::CkbRawTransactionHashWithoutCellDeps;
        let bytes32 = helper == RuntimeHelper::CkbWitnessBytes32;
        if !raw_transaction
            && !bytes32
            && !matches!(
                helper,
                RuntimeHelper::CkbCellDataBlake2bSpan | RuntimeHelper::CkbWitnessBlake2bSpan | RuntimeHelper::CkbWitnessBoundedBlake2b
            )
        {
            return Err(invalid_runtime_call(func));
        }
        let Some(dest) = dest else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        if args.len()
            != if raw_transaction {
                0
            } else if bytes32 {
                2
            } else {
                3
            }
            || if bytes32 { !crate::ir::is_raw_bytes32_runtime_result(helper, &dest.ty) } else { dest.ty != IrType::Hash }
        {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        let (Some(size), Some(buffer)) =
            (self.cell_buffer_size_offsets.get(&dest.id).copied(), self.cell_buffer_offsets.get(&dest.id).copied())
        else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        self.emit("li t0, 32");
        self.emit_stack_store("t0", size);
        // Arguments are lowered scalar locals/constants. No pointer-loading
        // helper is invoked while the earlier argument registers are live.
        if !raw_transaction {
            self.emit_operand_to_register("a0", &args[0]);
            self.emit_operand_to_register("a1", &args[1]);
            if !bytes32 {
                self.emit_operand_to_register("a2", &args[2]);
            }
        }
        self.emit_sp_addi("a3", buffer);
        self.emit(format!("call {func}"));
        let ok = self.fresh_label("span_hash_ok");
        self.emit(format!("beqz a0, {ok}"));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        self.emit_sp_addi("t0", buffer);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_witness_hash_call(&mut self, dest: Option<&IrVar>, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        let Some(dest) = dest else {
            return Err(invalid_runtime_call(func));
        };
        if args.len() != 1 || !crate::ir::is_raw_bytes32_runtime_result(helper, &dest.ty) {
            return Err(invalid_runtime_call(func));
        }
        let Some(size_offset) = self.cell_buffer_size_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: exact witness bytes destination has no 32-byte storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(buffer_offset) = self.cell_buffer_offsets.get(&dest.id).copied() else {
            self.emit("# cellscript abi: exact witness bytes destination has no buffer storage; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        self.emit("# cellscript abi: load an exact WitnessArgs field into [u8; 32]");
        self.emit("li t0, 32");
        self.emit_schema_size_store("t0", size_offset);
        self.emit_operand_to_register("a0", &args[0]);
        self.emit_sp_addi("a1", buffer_offset);
        self.emit(format!("call {}", func));
        let ok_label = self.fresh_label("witness_hash_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        self.emit_sp_addi("t0", buffer_offset);
        self.emit_stack_store("t0", self.scalar_slot_offset(dest.id));
        Ok(())
    }

    fn emit_runtime_fixed_hash_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 2 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[1], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let value = IrOperand::Const(IrConst::Array(bytes.into_iter().map(IrConst::U8).collect()));
                self.emit_store_fixed_byte_const_to_scratch(&value, size_offset, buffer_offset, 32);
                self.emit_sp_addi("a1", buffer_offset);
                self.emit("li a2, 32");
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "runtime expected hash");
                if self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("li a2, 32");
                } else {
                    self.emit("# cellscript abi: runtime expected hash source is not addressable; pass null to fail closed");
                    self.emit("li a1, 0");
                    self.emit("li a2, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: runtime expected hash source is unavailable; pass null to fail closed");
                self.emit("li a1, 0");
                self.emit("li a2, 0");
            }
        }

        self.emit_operand_to_register("a0", &args[0]);
        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_hash_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_exact_script_handle_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 3 {
            return Err(invalid_runtime_call(func));
        }

        let Some(handle) = self.expected_fixed_byte_source(&args[1], crate::script_handle_contract::EXACT_SCRIPT_HANDLE_BYTES) else {
            self.emit_fail(CellScriptRuntimeError::ExactScriptHandleInvalid);
            return Ok(());
        };
        let Some(receipt_hash) = self.expected_fixed_byte_source(&args[2], 32) else {
            self.emit_fail(CellScriptRuntimeError::ExactScriptHandleInvalid);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&handle, crate::script_handle_contract::EXACT_SCRIPT_HANDLE_BYTES, "exact Script handle");
        self.emit_prepare_fixed_byte_source(&receipt_hash, 32, "exact Script handle receipt hash");
        self.emit_operand_to_register("a0", &args[0]);
        if !self.emit_fixed_byte_source_pointer_or_const_to("a1", &handle) {
            self.emit_fail(CellScriptRuntimeError::ExactScriptHandleInvalid);
            return Ok(());
        }
        self.emit(format!("li a2, {}", crate::script_handle_contract::EXACT_SCRIPT_HANDLE_BYTES));
        if !self.emit_fixed_byte_source_pointer_or_const_to("a3", &receipt_hash) {
            self.emit_fail(CellScriptRuntimeError::ExactScriptHandleInvalid);
            return Ok(());
        }
        self.emit(format!("li a4, {}", crate::script_handle_contract::EXACT_SCRIPT_HANDLE_HASH_BYTES));
        self.emit(format!("call {func}"));
        let ok = self.fresh_label("exact_script_handle_requirement_ok");
        self.emit(format!("beqz a0, {ok}"));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        Ok(())
    }

    fn emit_runtime_open_handle_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if matches!(
            helper,
            RuntimeHelper::CkbRequireCellDepOpenScriptHandleFromArgs
                | RuntimeHelper::CkbRequireCellDepOpenVerifierHandleFromArgs
                | RuntimeHelper::CkbRequireOpenScriptParticipantFromArgs
                | RuntimeHelper::CkbRequireInstanceScriptParticipantFromArgs
        ) {
            let instance = helper == RuntimeHelper::CkbRequireInstanceScriptParticipantFromArgs;
            let participant = instance || helper == RuntimeHelper::CkbRequireOpenScriptParticipantFromArgs;
            let width = if instance { crate::script_handle_contract::INSTANCE_SCRIPT_HANDLE_BYTES } else { 656 };
            if args.len() != if participant { 3 } else { 2 } {
                return Err(invalid_runtime_call(func));
            }
            let Some(handle) = self.expected_fixed_byte_source(&args[1], width) else {
                self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
                return Ok(());
            };
            self.emit_prepare_fixed_byte_source(&handle, width, "versioned handle selection");
            self.emit_operand_to_register("a0", &args[0]);
            if !self.emit_fixed_byte_source_pointer_or_const_to("a1", &handle) {
                self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
                return Ok(());
            }
            self.emit(format!("li a2, {width}"));
            if participant {
                self.emit_operand_to_register("a3", &args[2]);
            } else {
                self.emit("li a3, 0");
            }
            self.emit("li a4, 0");
            self.emit(format!("call {func}"));
            let ok = self.fresh_label("open_handle_from_args_ok");
            self.emit(format!("beqz a0, {ok}"));
            self.emit_process_failure_status();
            self.emit_label(&ok);
            return Ok(());
        }
        if !matches!(helper, RuntimeHelper::CkbRequireCellDepOpenScriptHandle | RuntimeHelper::CkbRequireCellDepOpenVerifierHandle) {
            return Err(invalid_runtime_call(func));
        }
        if args.len() != 3 {
            return Err(invalid_runtime_call(func));
        }
        let Some(handle) = self.expected_fixed_byte_source(&args[1], 656) else {
            self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
            return Ok(());
        };
        let Some(expected_root) = self.expected_fixed_byte_source(&args[2], 32) else {
            self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&handle, 656, "compatible-open handle selection");
        self.emit_prepare_fixed_byte_source(&expected_root, 32, "compatible-open expected authorization root");
        self.emit_operand_to_register("a0", &args[0]);
        if !self.emit_fixed_byte_source_pointer_or_const_to("a1", &handle) {
            self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
            return Ok(());
        }
        self.emit("li a2, 656");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a3", &expected_root) {
            self.emit_fail(CellScriptRuntimeError::OpenHandleInvalid);
            return Ok(());
        }
        self.emit("li a4, 32");
        self.emit(format!("call {func}"));
        let ok = self.fresh_label("open_handle_requirement_ok");
        self.emit(format!("beqz a0, {ok}"));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        Ok(())
    }

    fn emit_runtime_deployment_line_handle_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        let (handle_index, hash_index) = match helper {
            RuntimeHelper::CkbRequireCellLockDeploymentLineHandle | RuntimeHelper::CkbRequireCellTypeDeploymentLineHandle
                if args.len() == 5 =>
            {
                (3, 4)
            }
            RuntimeHelper::CkbRequireCellDepDeploymentLineVerifierHandle if args.len() == 4 => (2, 3),
            RuntimeHelper::CkbRequireCellLockDeploymentLineHandle
            | RuntimeHelper::CkbRequireCellTypeDeploymentLineHandle
            | RuntimeHelper::CkbRequireCellDepDeploymentLineVerifierHandle => return Err(invalid_runtime_call(func)),
            _ => return Err(invalid_runtime_call(func)),
        };

        let Some(handle) =
            self.expected_fixed_byte_source(&args[handle_index], crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_BYTES)
        else {
            self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
            return Ok(());
        };
        let Some(handle_hash) = self.expected_fixed_byte_source(&args[hash_index], 32) else {
            self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(
            &handle,
            crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_BYTES,
            "deployment line handle",
        );
        self.emit_prepare_fixed_byte_source(&handle_hash, 32, "deployment line handle hash");

        if handle_index == 3 {
            self.emit_operand_to_register("a0", &args[0]);
            self.emit_operand_to_register("a1", &args[1]);
            self.emit_operand_to_register("a2", &args[2]);
            if !self.emit_fixed_byte_source_pointer_or_const_to("a3", &handle) {
                self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
                return Ok(());
            }
            self.emit(format!("li a4, {}", crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_BYTES));
            if !self.emit_fixed_byte_source_pointer_or_const_to("a5", &handle_hash) {
                self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
                return Ok(());
            }
            self.emit("li a6, 32");
        } else {
            self.emit_operand_to_register("a0", &args[0]);
            self.emit_operand_to_register("a1", &args[1]);
            if !self.emit_fixed_byte_source_pointer_or_const_to("a2", &handle) {
                self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
                return Ok(());
            }
            self.emit(format!("li a3, {}", crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_BYTES));
            if !self.emit_fixed_byte_source_pointer_or_const_to("a4", &handle_hash) {
                self.emit_fail(CellScriptRuntimeError::DeploymentLineHandleInvalid);
                return Ok(());
            }
            self.emit("li a5, 32");
        }
        self.emit(format!("call {func}"));
        let ok = self.fresh_label("deployment_line_handle_requirement_ok");
        self.emit(format!("beqz a0, {ok}"));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        Ok(())
    }

    fn emit_runtime_bounded_cell_dep_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 2 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[1], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let hash: [u8; 32] = bytes.as_slice().try_into().expect("expected fixed hash width");
                self.emit_store_fixed_byte_const_to_scratch(&IrOperand::Const(IrConst::Hash(hash)), size_offset, buffer_offset, 32);
                self.emit_sp_addi("a1", buffer_offset);
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "bounded CellDep expected data hash");
                if !self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("# cellscript abi: bounded CellDep expected hash is not addressable; pass null to fail closed");
                    self.emit("li a1, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: bounded CellDep expected hash is unavailable; pass null to fail closed");
                self.emit("li a1, 0");
            }
        }
        self.emit_operand_to_register("a0", &args[0]);
        self.emit("call __ckb_require_bounded_cell_dep_data_hash");
        let ok_label = self.fresh_label("bounded_cell_dep_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_sha256d_merkle_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 5 {
            return Err(invalid_runtime_call(func));
        }
        let Some(leaf) = self.expected_fixed_byte_source(&args[0], 32) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(siblings) = self.expected_fixed_byte_source(&args[1], 16 * 32) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(expected_root) = self.expected_fixed_byte_source(&args[4], 32) else {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        self.emit_prepare_fixed_byte_source(&leaf, 32, "SHA256d Merkle leaf");
        self.emit_prepare_fixed_byte_source(&siblings, 16 * 32, "SHA256d Merkle siblings");
        self.emit_prepare_fixed_byte_source(&expected_root, 32, "SHA256d Merkle expected root");
        if !self.emit_fixed_byte_source_pointer_or_const_to("a0", &leaf)
            || !self.emit_fixed_byte_source_pointer_or_const_to("a1", &siblings)
            || !self.emit_fixed_byte_source_pointer_or_const_to("a4", &expected_root)
        {
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        }
        self.emit_operand_to_register("a2", &args[2]);
        self.emit_operand_to_register("a3", &args[3]);
        self.emit("call __ckb_require_sha256d_merkle_root");
        let ok = self.fresh_label("sha256d_merkle_requirement_ok");
        self.emit(format!("beqz a0, {}", ok));
        self.emit_process_failure_status();
        self.emit_label(&ok);
        Ok(())
    }

    fn emit_runtime_cell_script_hash_type_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 3 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[1], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let hash: [u8; 32] = bytes.as_slice().try_into().expect("expected fixed hash width");
                self.emit_store_fixed_byte_const_to_scratch(&IrOperand::Const(IrConst::Hash(hash)), size_offset, buffer_offset, 32);
                self.emit_sp_addi("a1", buffer_offset);
                self.emit("li a2, 32");
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "runtime expected Script code hash");
                if self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("li a2, 32");
                } else {
                    self.emit(
                        "# cellscript abi: runtime expected Script code hash source is not addressable; pass null to fail closed",
                    );
                    self.emit("li a1, 0");
                    self.emit("li a2, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: runtime expected Script code hash is unavailable; pass null to fail closed");
                self.emit("li a1, 0");
                self.emit("li a2, 0");
            }
        }

        self.emit_operand_to_register("a0", &args[0]);
        self.emit_operand_to_register("a3", &args[2]);
        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_script_identity_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_cell_script_args_exact_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 2 {
            return Err(invalid_runtime_call(func));
        }
        let Some(width) = operand_fixed_byte_width(&args[1]) else {
            self.emit("# cellscript abi: runtime expected Script args source has no fixed byte width; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };
        let Some(expected) = self.expected_fixed_byte_source(&args[1], width) else {
            self.emit("# cellscript abi: runtime expected Script args source is unavailable; fail closed");
            self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
            return Ok(());
        };

        match expected {
            ExpectedFixedByteSource::Const(bytes) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                self.emit_store_fixed_byte_const_to_scratch(
                    &IrOperand::Const(IrConst::Array(bytes.into_iter().map(IrConst::U8).collect())),
                    size_offset,
                    buffer_offset,
                    width,
                );
                self.emit_sp_addi("a1", buffer_offset);
            }
            source => {
                self.emit_prepare_fixed_byte_source(&source, width, "runtime expected Script args");
                if !self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("# cellscript abi: runtime expected Script args source is not addressable; fail closed");
                    self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                    return Ok(());
                }
            }
        }

        self.emit_operand_to_register("a0", &args[0]);
        self.emit(format!("li a2, {}", width));
        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_script_args_exact_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_input_out_point_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 3 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[1], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let hash: [u8; 32] = bytes.as_slice().try_into().expect("expected fixed hash width");
                self.emit_store_fixed_byte_const_to_scratch(&IrOperand::Const(IrConst::Hash(hash)), size_offset, buffer_offset, 32);
                self.emit_sp_addi("a1", buffer_offset);
                self.emit("li a2, 32");
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "runtime expected input out point tx hash");
                if self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("li a2, 32");
                } else {
                    self.emit(
                        "# cellscript abi: runtime expected input out point hash source is not addressable; pass null to fail closed",
                    );
                    self.emit("li a1, 0");
                    self.emit("li a2, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: runtime expected input out point hash source is unavailable; pass null to fail closed");
                self.emit("li a1, 0");
                self.emit("li a2, 0");
            }
        }

        self.emit_operand_to_register("a3", &args[2]);
        self.emit_operand_to_register("a0", &args[0]);
        self.emit("call __ckb_require_input_out_point");
        let ok_label = self.fresh_label("runtime_input_out_point_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_xudt_type_args_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 3 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[1], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let hash: [u8; 32] = bytes.as_slice().try_into().expect("expected fixed hash width");
                self.emit_store_fixed_byte_const_to_scratch(&IrOperand::Const(IrConst::Hash(hash)), size_offset, buffer_offset, 32);
                self.emit_sp_addi("a1", buffer_offset);
                self.emit("li a2, 32");
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "runtime expected xUDT owner hash");
                if self.emit_fixed_byte_source_pointer_to("a1", &source) {
                    self.emit("li a2, 32");
                } else {
                    self.emit("# cellscript abi: runtime xUDT owner hash source is not addressable; pass null to fail closed");
                    self.emit("li a1, 0");
                    self.emit("li a2, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: runtime xUDT owner hash source is unavailable; pass null to fail closed");
                self.emit("li a1, 0");
                self.emit("li a2, 0");
            }
        }

        self.emit_operand_to_register("a0", &args[0]);
        self.emit_operand_to_register("a3", &args[2]);
        self.emit("call __xudt_require_owner_mode_type_args");
        let ok_label = self.fresh_label("runtime_xudt_args_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_xudt_group_amount_delta_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 1 {
            return Err(invalid_runtime_call(func));
        }

        let source = self.expected_fixed_byte_source(&args[0], 16);
        match source {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let value = u128::from_le_bytes(bytes.as_slice().try_into().expect("expected fixed u128 width"));
                let buffer_offset = self.runtime_scratch_buffer_offset();
                self.emit_store_fixed_byte_const_to_scratch(
                    &IrOperand::Const(IrConst::U128(value)),
                    self.runtime_scratch_size_offset(),
                    buffer_offset,
                    16,
                );
                self.emit_sp_addi("a0", buffer_offset);
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 16, "runtime xUDT group amount delta");
                if !self.emit_fixed_byte_source_pointer_to("a0", &source) {
                    self.emit("# cellscript abi: xUDT group amount delta is not addressable; pass null to fail closed");
                    self.emit("li a0, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: xUDT group amount delta is unavailable; pass null to fail closed");
                self.emit("li a0, 0");
            }
        }

        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_xudt_delta_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_metapoint_filtered_pair_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 4 {
            return Err(invalid_runtime_call(func));
        }

        let expected = self.expected_fixed_byte_source(&args[2], 32);
        match expected {
            Some(ExpectedFixedByteSource::Const(bytes)) => {
                let size_offset = self.runtime_scratch_size_offset();
                let buffer_offset = self.runtime_scratch_buffer_offset();
                let hash: [u8; 32] = bytes.as_slice().try_into().expect("expected fixed hash width");
                self.emit_store_fixed_byte_const_to_scratch(&IrOperand::Const(IrConst::Hash(hash)), size_offset, buffer_offset, 32);
                self.emit_sp_addi("a2", buffer_offset);
                self.emit("li a3, 32");
            }
            Some(source) => {
                self.emit_prepare_fixed_byte_source(&source, 32, "runtime filtered MetaPoint related type hash");
                if self.emit_fixed_byte_source_pointer_to("a2", &source) {
                    self.emit("li a3, 32");
                } else {
                    self.emit("# cellscript abi: filtered MetaPoint expected type hash is not addressable; pass null to fail closed");
                    self.emit("li a2, 0");
                    self.emit("li a3, 0");
                }
            }
            None => {
                self.emit("# cellscript abi: filtered MetaPoint expected type hash is unavailable; pass null to fail closed");
                self.emit("li a2, 0");
                self.emit("li a3, 0");
            }
        }

        self.emit_operand_to_register("a0", &args[0]);
        self.emit_operand_to_register("a1", &args[1]);
        self.emit_operand_to_register("a4", &args[3]);
        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_metapoint_filtered_pair_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_c256_product_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 4 {
            return Err(invalid_runtime_call(func));
        }

        let scratch_base = self.runtime_scratch_buffer_offset();
        for (index, (register, arg)) in ["a0", "a1", "a2", "a3"].into_iter().zip(args.iter()).enumerate() {
            let source = self.expected_fixed_byte_source(arg, 16);
            match source {
                Some(ExpectedFixedByteSource::Const(bytes)) => {
                    let value = u128::from_le_bytes(bytes.as_slice().try_into().expect("expected fixed u128 width"));
                    let buffer_offset = scratch_base + index * 16;
                    self.emit_store_fixed_byte_const_to_scratch(
                        &IrOperand::Const(IrConst::U128(value)),
                        self.runtime_scratch_size_offset(),
                        buffer_offset,
                        16,
                    );
                    self.emit_sp_addi(register, buffer_offset);
                }
                Some(source) => {
                    self.emit_prepare_fixed_byte_source(&source, 16, "runtime c256 u128 product operand");
                    if !self.emit_fixed_byte_source_pointer_to(register, &source) {
                        self.emit(format!(
                            "# cellscript abi: c256 product operand {} is not addressable; pass null to fail closed",
                            index
                        ));
                        self.emit(format!("li {}, 0", register));
                    }
                }
                None => {
                    self.emit(format!("# cellscript abi: c256 product operand {} is unavailable; pass null to fail closed", index));
                    self.emit(format!("li {}, 0", register));
                }
            }
        }

        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_c256_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_runtime_c256_sum2_product_requirement_call(&mut self, helper: RuntimeHelper, args: &[IrOperand]) -> Result<()> {
        let func = helper.symbol();
        if args.len() != 8 {
            return Err(invalid_runtime_call(func));
        }

        let scratch_base = self.runtime_scratch_buffer_offset();
        for (index, (register, arg)) in ["a0", "a1", "a2", "a3", "a4", "a5", "a6", "a7"].into_iter().zip(args.iter()).enumerate() {
            let source = self.expected_fixed_byte_source(arg, 16);
            match source {
                Some(ExpectedFixedByteSource::Const(bytes)) => {
                    let value = u128::from_le_bytes(bytes.as_slice().try_into().expect("expected fixed u128 width"));
                    let buffer_offset = scratch_base + index * 16;
                    self.emit_store_fixed_byte_const_to_scratch(
                        &IrOperand::Const(IrConst::U128(value)),
                        self.runtime_scratch_size_offset(),
                        buffer_offset,
                        16,
                    );
                    self.emit_sp_addi(register, buffer_offset);
                }
                Some(source) => {
                    self.emit_prepare_fixed_byte_source(&source, 16, "runtime c256 sum-product operand");
                    if !self.emit_fixed_byte_source_pointer_to(register, &source) {
                        self.emit(format!(
                            "# cellscript abi: c256 sum-product operand {} is not addressable; pass null to fail closed",
                            index
                        ));
                        self.emit(format!("li {}, 0", register));
                    }
                }
                None => {
                    self.emit(format!(
                        "# cellscript abi: c256 sum-product operand {} is unavailable; pass null to fail closed",
                        index
                    ));
                    self.emit(format!("li {}, 0", register));
                }
            }
        }

        self.emit("call ".to_string() + func);
        let ok_label = self.fresh_label("runtime_c256_sum_requirement_ok");
        self.emit(format!("beqz a0, {}", ok_label));
        self.emit_process_failure_status();
        self.emit_label(&ok_label);
        Ok(())
    }

    fn emit_call_param_arg(
        &mut self,
        func: &str,
        param: &IrParam,
        needs_type_hash: bool,
        abi_index: &mut usize,
        arg: &IrOperand,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        if is_ckb_temporal_scalar_ir_type(&param.ty) {
            return self.emit_call_scalar_arg(func, &param.name, abi_index, arg, outgoing_stack_arg_bytes);
        }
        if let IrType::Named(name) = &param.ty
            && let Some(layout) = self.enum_layouts.get(name).filter(|layout| layout.has_payload())
        {
            let width = layout.encoded_size;
            self.emit(format!(
                "# cellscript abi: call {} payload enum param {} pointer={} length={} size={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1),
                width
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, Some(width), outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::FixedBytes, outgoing_stack_arg_bytes) {
                return false;
            }
            return true;
        }
        if let Some(width) = self.fieldless_enum_width(&param.ty) {
            self.emit(format!(
                "# cellscript abi: call {} fieldless enum param {} value={} width={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                width
            ));
            if !self.emit_call_scalar_arg(func, &param.name, abi_index, arg, outgoing_stack_arg_bytes) {
                return false;
            }
            let register = self.call_abi_register(*abi_index);
            self.emit(format!("li {}, 0", register));
            self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
            *abi_index += 1;
            return true;
        }
        if let Some(width) = self.fixed_named_parameter_width(&param.ty) {
            self.emit(format!(
                "# cellscript abi: call {} fixed named-value param {} pointer={} length={} size={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1),
                width
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, Some(width), outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::FixedBytes, outgoing_stack_arg_bytes) {
                return false;
            }
            return true;
        }
        if matches!(&param.ty, IrType::Named(name) if name == crate::script_handle_contract::EXACT_SCRIPT_HANDLE_TYPE) {
            let width = crate::script_handle_contract::EXACT_SCRIPT_HANDLE_BYTES;
            self.emit(format!(
                "# cellscript abi: call {} exact Script handle param {} pointer={} length={} size={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1),
                width
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, Some(width), outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::FixedBytes, outgoing_stack_arg_bytes) {
                return false;
            }
            return true;
        }
        if matches!(&param.ty, IrType::Named(name) if name == crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_TYPE) {
            let width = crate::script_handle_contract::DEPLOYMENT_LINE_HANDLE_BYTES;
            self.emit(format!(
                "# cellscript abi: call {} deployment line handle param {} pointer={} length={} size={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1),
                width
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, Some(width), outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::FixedBytes, outgoing_stack_arg_bytes) {
                return false;
            }
            return true;
        }
        if uses_schema_span_abi(&param.ty) {
            if param.ty.vector_element().is_some()
                && let IrOperand::Var(var) = arg
                && self.stack_collection_vars.contains(&var.id)
            {
                return self.emit_stack_vector_call_arg(param, abi_index, var, outgoing_stack_arg_bytes);
            }
            self.emit(format!(
                "# cellscript abi: call {} schema param {} pointer={} length={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1)
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, None, outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::Schema, outgoing_stack_arg_bytes) {
                return false;
            }
            if needs_type_hash {
                self.emit(format!(
                    "# cellscript abi: call {} schema param {} type_hash pointer={} length={} size=32",
                    func,
                    param.name,
                    abi_arg_label(*abi_index),
                    abi_arg_label(*abi_index + 1)
                ));
                if !self.emit_call_type_hash_pointer_arg(func, &param.name, abi_index, arg, outgoing_stack_arg_bytes) {
                    return false;
                }
                if !self.emit_call_type_hash_length_arg(func, &param.name, abi_index, arg, outgoing_stack_arg_bytes) {
                    return false;
                }
            }
            return true;
        }

        let fixed_pointer_width = fixed_byte_pointer_param_width(&param.ty).or_else(|| fixed_aggregate_pointer_param_width(&param.ty));
        if let Some(width) = fixed_pointer_width {
            self.emit(format!(
                "# cellscript abi: call {} fixed-byte param {} pointer={} length={} size={}",
                func,
                param.name,
                abi_arg_label(*abi_index),
                abi_arg_label(*abi_index + 1),
                width
            ));
            if !self.emit_call_pointer_arg(func, &param.name, abi_index, arg, Some(width), outgoing_stack_arg_bytes) {
                return false;
            }
            if !self.emit_call_length_arg(func, &param.name, abi_index, arg, CallLengthKind::FixedBytes, outgoing_stack_arg_bytes) {
                return false;
            }
            return true;
        }

        self.emit_call_scalar_arg(func, &param.name, abi_index, arg, outgoing_stack_arg_bytes)
    }

    /// Copy a local stack vector into the immutable FixVec span expected by
    /// an ordinary parameter. Only t0-t6 are clobbered; a0-a7 may already hold
    /// earlier arguments. The original length word and data stay untouched.
    fn emit_stack_vector_call_arg(
        &mut self,
        param: &IrParam,
        abi_index: &mut usize,
        var: &IrVar,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let Some(width) = molecule_vector_element_fixed_width(&param.ty, &self.type_fixed_sizes, &self.enum_fixed_sizes)
            .filter(|width| *width <= RUNTIME_COLLECTION_BUFFER_SIZE)
        else {
            self.emit_fail(CellScriptRuntimeError::CollectionBoundsInvalid);
            return false;
        };
        let Some(offset) = self.stack_vector_argument_buffers.get(&var.id).copied() else {
            self.emit_fail(CellScriptRuntimeError::CollectionBoundsInvalid);
            return false;
        };
        self.emit(format!("# cellscript abi: copy stack vector param {} to canonical FixVec element_size={width}", param.name));
        self.emit_stack_load("t4", self.scalar_slot_offset(var.id));
        self.emit_load(LoadOp::Double, "t0", "t4", -8);
        self.emit(format!("li t5, {}", RUNTIME_COLLECTION_BUFFER_SIZE / width));
        let bounded = self.fresh_label("vector_argument_bounded");
        self.emit(format!("bgeu t5, t0, {bounded}"));
        self.emit_fail(CellScriptRuntimeError::CollectionBoundsInvalid);
        self.emit_label(&bounded);
        self.emit_sp_addi("t6", offset);
        self.emit_store(StoreOp::Word, "t0", "t6", 0);
        self.emit(format!("li t1, {width}"));
        self.emit("mul t2, t0, t1");
        self.emit_add_immediate("t6", "t6", 4);
        self.emit("li t1, 0");
        let copy = self.fresh_label("vector_argument_copy");
        let copied = self.fresh_label("vector_argument_copied");
        self.emit_label(&copy);
        self.emit(format!("beq t1, t2, {copied}"));
        self.emit_load(LoadOp::ByteUnsigned, "t3", "t4", 0);
        self.emit_store(StoreOp::Byte, "t3", "t6", 0);
        self.emit_add_immediate("t4", "t4", 1);
        self.emit_add_immediate("t6", "t6", 1);
        self.emit_add_immediate("t1", "t1", 1);
        self.emit(format!("j {copy}"));
        self.emit_label(&copied);

        let pointer = self.call_abi_register(*abi_index);
        self.emit_sp_addi(&pointer, offset);
        self.emit_outgoing_call_stack_arg_store(&pointer, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        // Recompute after the pointer store: stack-passed arguments may use
        // t0, and large outgoing addressing owns its scratch registers.
        self.emit_stack_load("t4", self.scalar_slot_offset(var.id));
        self.emit_load(LoadOp::Double, "t0", "t4", -8);
        self.emit(format!("li t1, {width}"));
        self.emit("mul t0, t0, t1");
        let length = self.call_abi_register(*abi_index);
        self.emit_add_immediate(&length, "t0", 4);
        self.emit_outgoing_call_stack_arg_store(&length, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_call_scalar_arg(
        &mut self,
        func: &str,
        label: &str,
        abi_index: &mut usize,
        arg: &IrOperand,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let register = self.call_abi_register(*abi_index);
        self.emit(format!("# cellscript abi: call {} scalar {} -> {}", func, label, register));
        if !self.emit_small_byte_array_register(&register, arg) {
            self.emit_operand_to_register(&register, arg);
        }
        self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_call_pointer_arg(
        &mut self,
        func: &str,
        label: &str,
        abi_index: &mut usize,
        arg: &IrOperand,
        const_width: Option<usize>,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let register = self.call_abi_register(*abi_index);
        if let (Some(width), IrOperand::Const(value)) = (const_width, arg) {
            let Some(bytes) = fixed_byte_const_bytes(value).filter(|bytes| bytes.len() == width) else {
                self.emit(format!("# cellscript abi: call {func} pointer param {label} has no exact-width constant storage"));
                self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                return false;
            };
            // Ordinary value parameters borrow immutable constant storage for
            // the call. Use the same little-endian bytes as local materialization.
            let data = self.const_data_label_for_bytes(bytes);
            self.emit(format!("la {register}, {data}"));
        } else {
            self.emit_operand_to_register(&register, arg);
        }
        self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_call_length_arg(
        &mut self,
        func: &str,
        label: &str,
        abi_index: &mut usize,
        arg: &IrOperand,
        kind: CallLengthKind,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let register = self.call_abi_register(*abi_index);
        let size_offset = match (arg, kind) {
            (IrOperand::Var(var), CallLengthKind::Schema) if Self::nested_type(&var.ty).is_some() => self.nested_size_offset(var),
            (IrOperand::Var(var), CallLengthKind::Schema) => self.schema_pointer_size_offsets.get(&var.id).copied(),
            (IrOperand::Var(var), CallLengthKind::FixedBytes) => self.fixed_byte_param_size_offsets.get(&var.id).copied(),
            _ => None,
        };
        if let Some(size_offset) = size_offset {
            self.emit_stack_load(&register, size_offset);
        } else if let (IrOperand::Var(var), CallLengthKind::Schema) = (arg, kind)
            && let Some(width) = self.allocated_owner_extents.get(&var.id)
        {
            self.emit(format!("li {}, {}", register, width));
        } else if let (IrOperand::Var(var), CallLengthKind::Schema) = (arg, kind)
            && let Some(width) = self.local_schema_value_widths.get(&var.id).copied()
        {
            self.emit(format!("# cellscript abi: locally materialized schema value var{} has exact width {}", var.id, width));
            self.emit(format!("li {}, {}", register, width));
        } else if let (IrOperand::Var(var), CallLengthKind::FixedBytes) = (arg, kind) {
            if let Some(width) = self.fixed_named_type_width(&var.ty) {
                self.emit(format!("li {}, {}", register, width));
            } else if self.fixed_byte_local_offsets.contains_key(&var.id)
                && let Some(width) = operand_fixed_byte_width(arg)
            {
                // A locally materialized fixed-byte value owns exact-width
                // storage. Unlike a borrowed parameter it needs no length slot.
                self.emit(format!("# cellscript abi: local fixed-byte value var{} has exact width {}", var.id, width));
                self.emit(format!("li {}, {}", register, width));
            } else {
                self.emit(format!(
                    "# cellscript abi: call {} fixed-byte param {} has no tracked ABI length; pass zero length to fail closed",
                    func, label
                ));
                self.emit(format!("li {}, 0", register));
            }
        } else if let CallLengthKind::FixedBytes = kind {
            if let IrOperand::Const(value) = arg {
                let Some(bytes) = fixed_byte_const_bytes(value) else {
                    self.emit_fail(CellScriptRuntimeError::FixedByteComparisonUnresolved);
                    return false;
                };
                self.emit(format!("li {register}, {}", bytes.len()));
            } else {
                self.emit(format!(
                    "# cellscript abi: call {} fixed-byte param {} has no tracked ABI length; pass zero length to fail closed",
                    func, label
                ));
                self.emit(format!("li {}, 0", register));
            }
        } else {
            self.emit(format!(
                "# cellscript abi: call {} schema param {} has no tracked ABI length; pass zero length to fail closed",
                func, label
            ));
            self.emit(format!("li {}, 0", register));
        }
        self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_call_type_hash_pointer_arg(
        &mut self,
        func: &str,
        label: &str,
        abi_index: &mut usize,
        arg: &IrOperand,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let register = self.call_abi_register(*abi_index);
        if let IrOperand::Var(var) = arg {
            if let Some(pointer_offset) = self.param_type_hash_pointer_offsets.get(&var.id).copied() {
                self.emit_stack_load(&register, pointer_offset);
            } else {
                self.emit(format!(
                    "# cellscript abi: call {} schema param {} has no tracked TypeHash pointer; pass null pointer",
                    func, label
                ));
                self.emit(format!("li {}, 0", register));
            }
        } else {
            self.emit(format!(
                "# cellscript abi: call {} schema param {} TypeHash source is not a variable; pass null pointer",
                func, label
            ));
            self.emit(format!("li {}, 0", register));
        }
        self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_call_type_hash_length_arg(
        &mut self,
        func: &str,
        label: &str,
        abi_index: &mut usize,
        arg: &IrOperand,
        outgoing_stack_arg_bytes: usize,
    ) -> bool {
        let register = self.call_abi_register(*abi_index);
        if let IrOperand::Var(var) = arg {
            if let Some(size_offset) = self.param_type_hash_size_offsets.get(&var.id).copied() {
                self.emit_stack_load(&register, size_offset);
            } else {
                self.emit(format!(
                    "# cellscript abi: call {} schema param {} has no tracked TypeHash length; pass zero length to fail closed",
                    func, label
                ));
                self.emit(format!("li {}, 0", register));
            }
        } else {
            self.emit(format!(
                "# cellscript abi: call {} schema param {} TypeHash length source is not a variable; pass zero length",
                func, label
            ));
            self.emit(format!("li {}, 0", register));
        }
        self.emit_outgoing_call_stack_arg_store(&register, *abi_index, outgoing_stack_arg_bytes);
        *abi_index += 1;
        true
    }

    fn emit_outgoing_call_stack_arg_store(&mut self, register: &str, abi_index: usize, outgoing_stack_arg_bytes: usize) {
        if abi_index < 8 {
            return;
        }
        let stack_slot_offset = (abi_index - 8) * 8;
        let offset = i64::try_from(stack_slot_offset).expect("call stack slot should fit in i64")
            - i64::try_from(outgoing_stack_arg_bytes).expect("call stack argument area should fit in i64");
        self.emit(format!(
            "# cellscript abi: stage outgoing stack arg{} at pre-call sp{}{}",
            abi_index,
            if offset < 0 { "" } else { "+" },
            offset
        ));
        self.emit_sp_store_signed(register, offset);
    }

    pub(super) fn emit_sp_store_signed(&mut self, register: &str, offset: i64) {
        if small_signed_immediate(offset) {
            self.emit_store(StoreOp::Double, register, "sp", offset);
        } else {
            let Some(scratch) = self.reserve_scratch(&[register]) else {
                return;
            };
            self.emit(format!("li {}, {}", scratch, offset));
            self.emit(format!("add {}, sp, {}", scratch, scratch));
            self.emit_store(StoreOp::Double, register, scratch, 0);
        }
    }

    fn call_abi_register(&self, abi_index: usize) -> String {
        if abi_index < 8 {
            format!("a{}", abi_index)
        } else {
            "t0".to_string()
        }
    }
}

fn invalid_runtime_call(symbol: &str) -> CompileError {
    CompileError::without_span(format!("runtime call '{symbol}' has no registered target or its operands violate its selected ABI"))
        .with_code(crate::error::DiagnosticCode::E2100)
}