Verifying Bitcoin Transactions on Starknet: BitcoinDepositor Tutorial

#[starknet::interface]
pub trait IBitcoinDepositor<TContractState> {
    fn prove_deposit(
        ref self: TContractState,
        deposit_tx: Transaction,
        output_id: usize,
        block_height: u64,
        block_header: BlockHeader,
        tx_inclusion: Array<(Digest, bool)>
    );
    fn get_depositor(self: @TContractState) -> ContractAddress;
}

#[storage]
struct Storage {
    depositor: ContractAddress,
    utu_address: ContractAddress,
}

#[external(v0)]
impl BitcoinDepositor of IBitcoinDepositor<ContractState> {
    fn prove_deposit(
        ref self: ContractState,
        deposit_tx: Transaction,
        output_id: usize,
        block_height: u64,
        block_header: BlockHeader,
        tx_inclusion: Array<(Digest, bool)>
    ) {
        // Check no previous depositor
        assert(self.depositor.read() == Zero::zero(), 'too late, someone deposited');
        
        // 1. Verify amount and recipient
        let output_to_check = deposit_tx.outputs[output_id];
        assert(*output_to_check.value > 100_000_000_u64, 'you sent less than 1 BTC');
        let target = extract_p2pkh_target(*output_to_check.pk_script);
        assert(target == "1LgXWxpELt2o9hPGiwqDT1B5Z7994MQPTN", 'wrong receiver');

        // 2. Verify transaction inclusion in block
        let tx_bytes_legacy = @deposit_tx.encode();
        let txid = double_sha256_byte_array(tx_bytes_legacy);
        let merkle_root = compute_merkle_root(txid, tx_inclusion);
        assert(
            block_header.merkle_root_hash.value == merkle_root.value, 
            'invalid inclusion proof'
        );

        // 3. Verify block is in canonical chain and has sufficient proof of work
        let utu = IUtuRelayDispatcher { contract_address: self.utu_address.read() };
        // Requires 100 sextillion (10^36) expected hashes (strong security)
        utu.assert_safe(block_height, block_header.hash(), 100_000_000_000_000_000_000_000, 0);

        // 4. Verify block timestamp is not from the future
        let block_time = u32_byte_reverse(block_header.time).into();
        assert(block_time <= get_block_timestamp(), 'Block comes from the future');

        // Set depositor
        self.depositor.write(get_caller_address());
    }

    fn get_depositor(self: @ContractState) -> ContractAddress {
        self.depositor.read()
    }
}

import {
  BitcoinProxiedRpcProvider,
  UtuProvider,
  serializedHash,
} from "bitcoin-on-starknet";
import { Account, RpcProvider, TransactionType, Invocations } from "starknet";
 
// Pre-formatted transaction data for Starknet processing
const EXAMPLE_SERIALIZED_TRANSACTION = [
  2n, 0n, 1n, 4n,
  // ... transaction details ...
  744843869111954496999033090920949585736336206836849668294828n,
  25n, 0n, 0n,
] as const;
 
async function main() {
  // Initialize providers
  const bitcoinProvider = new BitcoinProxiedRpcProvider("https://btcrpc.lfg.rs/rpc");
  const utuProvider = new UtuProvider(bitcoinProvider);
  const starknetProvider = new RpcProvider({
    nodeUrl: "https://sepolia.rpc.starknet.id",
  });
 
  // Initialize Starknet account
  const account = new Account(
    starknetProvider,
    process.env.STARKNET_ADDRESS as string,
    process.env.STARKNET_PRIVATE_KEY as string
  );
 
  try {
    // Fetch transaction and generate proof
    const txId = "fa89c32152bf324cd1d47d48187f977c7e0f380f6f78132c187ce27923f62fcc";
    const rawTransaction = await bitcoinProvider.getRawTransaction(txId, true);
    const header = await bitcoinProvider.getBlockHeader(rawTransaction.blockhash);
    
    // Generate sync transactions and Merkle proof
    const syncTransactions = await utuProvider.getSyncTxs(
      starknetProvider,
      header.height,
      0n
    );
    const txInclusionProof = await utuProvider.getTxInclusionProof(txId);
 
    // Prepare calldata for prove_deposit
    let calldata = EXAMPLE_SERIALIZED_TRANSACTION.map(n => "0x" + n.toString(16));
    calldata.push("0x0"); // output_id
    calldata.push("0x" + header.height.toString(16));
    calldata.push(...utuProvider.serializeBlockHeader(header));
    
    // Add Merkle proof
    calldata.push(txInclusionProof.length);
    txInclusionProof.forEach(([hash, direction]: [string, boolean]) => {
      calldata.push(...serializedHash(hash));
      calldata.push(direction ? "0x1" : "0x0");
    });
 
    // Send a multicall syncing the chain before interacting with our contract
    await account.execute([...syncTransactions, proveDepositCall]);
  } catch (error) {
    console.error("Error:", error);
  }
}
 
main();