use alloy_primitives::{keccak256, Address, B256, U256};
#[cfg(test)]
use alloy_sol_types::SolCall;
use alloy_sol_types::{sol, SolValue};
sol! {
#[allow(missing_docs)]
contract TaskEscrow {
function open(
address token,
uint256 deposit,
address worker,
uint256 platformFeeAmount,
address platform,
bytes32 salt
) external returns (bytes32);
function openWithMemo(
address token,
uint256 deposit,
address worker,
uint256 platformFeeAmount,
address platform,
bytes32 salt,
bytes32 memoHash
) external returns (bytes32);
}
#[allow(missing_docs)]
contract IERC20 {
function approve(address spender, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
}
}
pub fn compute_escrow_id(
poster: Address,
worker: Address,
token: Address,
deposit: U256,
platform_fee_amount: U256,
platform: Address,
salt: B256,
) -> B256 {
let encoded = (
poster,
worker,
token,
deposit,
platform_fee_amount,
platform,
salt,
)
.abi_encode();
keccak256(encoded)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compute_escrow_id_matches_known_vector() {
let poster: Address = "0x0000000000000000000000000000000000000001"
.parse()
.unwrap();
let worker: Address = "0x0000000000000000000000000000000000000002"
.parse()
.unwrap();
let token: Address = "0x0000000000000000000000000000000000000003"
.parse()
.unwrap();
let platform: Address = "0x0000000000000000000000000000000000000004"
.parse()
.unwrap();
let deposit = U256::from(1_000_000_000u64);
let fee = U256::from(50_000_000u64);
let mut salt_bytes = [0u8; 32];
salt_bytes[31] = 0x42;
let salt = B256::from(salt_bytes);
let id = compute_escrow_id(poster, worker, token, deposit, fee, platform, salt);
let manual = keccak256((poster, worker, token, deposit, fee, platform, salt).abi_encode());
assert_eq!(id, manual);
assert_eq!(id.len(), 32);
}
#[test]
fn compute_escrow_id_is_salt_sensitive() {
let p = Address::ZERO;
let token = Address::ZERO;
let deposit = U256::from(1u64);
let fee = U256::from(0u64);
let mut salt_a = [0u8; 32];
salt_a[31] = 0x01;
let mut salt_b = [0u8; 32];
salt_b[31] = 0x02;
let a = compute_escrow_id(p, p, token, deposit, fee, p, B256::from(salt_a));
let b = compute_escrow_id(p, p, token, deposit, fee, p, B256::from(salt_b));
assert_ne!(a, b, "distinct salts must produce distinct escrow ids");
}
#[test]
fn approve_calldata_has_expected_selector() {
let call = IERC20::approveCall {
spender: Address::ZERO,
amount: U256::from(1u64),
};
let data = call.abi_encode();
assert_eq!(&data[0..4], &[0x09, 0x5e, 0xa7, 0xb3]);
}
#[test]
fn open_calldata_has_expected_selector() {
let call = TaskEscrow::openCall {
token: Address::ZERO,
deposit: U256::from(1u64),
worker: Address::ZERO,
platformFeeAmount: U256::from(0u64),
platform: Address::ZERO,
salt: B256::ZERO,
};
let data = call.abi_encode();
assert!(data.len() >= 4);
}
}