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,
address arbitrator,
bytes32 salt
) external returns (bytes32);
function openWithMemo(
address token,
uint256 deposit,
address worker,
uint256 platformFeeAmount,
address platform,
address arbitrator,
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 struct EscrowIdParams {
pub poster: Address,
pub worker: Address,
pub token: Address,
pub deposit: U256,
pub platform_fee_amount: U256,
pub platform: Address,
pub arbitrator: Address,
pub salt: B256,
}
pub fn compute_escrow_id(p: &EscrowIdParams) -> B256 {
let encoded = (
p.poster,
p.worker,
p.token,
p.deposit,
p.platform_fee_amount,
p.platform,
p.arbitrator,
p.salt,
)
.abi_encode();
keccak256(encoded)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn compute_escrow_id_matches_known_vector() {
let mut salt_bytes = [0u8; 32];
salt_bytes[31] = 0x42;
let params = EscrowIdParams {
poster: "0x0000000000000000000000000000000000000001"
.parse()
.unwrap(),
worker: "0x0000000000000000000000000000000000000002"
.parse()
.unwrap(),
token: "0x0000000000000000000000000000000000000003"
.parse()
.unwrap(),
deposit: U256::from(1_000_000_000u64),
platform_fee_amount: U256::from(50_000_000u64),
platform: "0x0000000000000000000000000000000000000004"
.parse()
.unwrap(),
arbitrator: "0x0000000000000000000000000000000000000005"
.parse()
.unwrap(),
salt: B256::from(salt_bytes),
};
let expected: B256 = "0x1fada0b25ef1b0a435fd6b8ef78d4a068b13e77c95bb29635397ab0106835363"
.parse()
.expect("pinned escrow-id vector");
assert_eq!(compute_escrow_id(¶ms), expected);
}
#[test]
fn compute_escrow_id_is_salt_sensitive() {
let base = |salt: B256| EscrowIdParams {
poster: Address::ZERO,
worker: Address::ZERO,
token: Address::ZERO,
deposit: U256::from(1u64),
platform_fee_amount: U256::from(0u64),
platform: Address::ZERO,
arbitrator: Address::ZERO,
salt,
};
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(&base(B256::from(salt_a)));
let b = compute_escrow_id(&base(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,
arbitrator: Address::ZERO,
salt: B256::ZERO,
};
let data = call.abi_encode();
let expected =
&keccak256("open(address,uint256,address,uint256,address,address,bytes32)")[..4];
assert_eq!(&data[0..4], expected);
}
}