feat(tip-1028): implement address-level receive policies

crates/contracts/src/precompiles/escrow.rs

@@ -0,0 +1,63 @@
+pub use ITIP1028Escrow::{
+    ITIP1028EscrowErrors as TIP1028EscrowError, ITIP1028EscrowEvents as TIP1028EscrowEvent,
+};
+
+crate::sol! {
+    #[derive(Debug, PartialEq, Eq)]
+    #[sol(abi)]
+    interface ITIP1028Escrow {
+        enum InboundKind {
+            TRANSFER,
+            MINT
+        }
+
+        struct ClaimReceiptV1 {
+            address originator;
+            address recipient;
+            uint64 blockedAt;
+            uint64 blockedNonce;
+            uint8 blockedReason;
+            InboundKind kind;
+            bytes32 memo;
+        }
+
+        function blockedReceiptBalance(address token, address recoveryContract, uint8 receiptVersion, bytes calldata receipt) external view returns (uint256 amount);
+        function claimBlocked(address token, address recoveryContract, uint8 receiptVersion, bytes calldata receipt, address to) external;
+
+        event TransferBlocked(address indexed token, address indexed from, address indexed receiver, uint8 receiptVersion, uint64 blockedNonce, uint64 blockedAt, address recipient, uint256 amount, uint8 blockedReason, address recoveryContract, bytes32 memo);
+        event BlockedReceiptClaimed(address indexed token, address indexed receiver, uint8 receiptVersion, uint64 indexed blockedNonce, uint64 blockedAt, address originator, address recipient, address recoveryContract, address caller, address to, uint256 amount);
+
+        error UnauthorizedClaimer();
+        error InvalidReceiptClaim();
+        error InsufficientEscrowBalance();
+        error EscrowAddressReserved();
+        error InvalidClaimAddress();
+        error InvalidToken();
+    }
+}
+
+impl TIP1028EscrowError {
+    pub const fn unauthorized_claimer() -> Self {
+        Self::UnauthorizedClaimer(ITIP1028Escrow::UnauthorizedClaimer {})
+    }
+
+    pub const fn invalid_receipt_claim() -> Self {
+        Self::InvalidReceiptClaim(ITIP1028Escrow::InvalidReceiptClaim {})
+    }
+
+    pub const fn insufficient_escrow_balance() -> Self {
+        Self::InsufficientEscrowBalance(ITIP1028Escrow::InsufficientEscrowBalance {})
+    }
+
+    pub const fn escrow_address_reserved() -> Self {
+        Self::EscrowAddressReserved(ITIP1028Escrow::EscrowAddressReserved {})
+    }
+
+    pub const fn invalid_claim_address() -> Self {
+        Self::InvalidClaimAddress(ITIP1028Escrow::InvalidClaimAddress {})
+    }
+
+    pub const fn invalid_token() -> Self {
+        Self::InvalidToken(ITIP1028Escrow::InvalidToken {})
+    }
+}

crates/contracts/src/precompiles/mod.rs

@@ -1,6 +1,7 @@
 pub mod account_keychain;
 pub mod address_registry;
 pub mod common_errors;
+pub mod escrow;
 pub mod nonce;
 pub mod signature_verifier;
 pub mod stablecoin_dex;
@@ -15,6 +16,7 @@ pub use account_keychain::*;
 pub use address_registry::*;
 use alloy_primitives::{Address, address};
 pub use common_errors::*;
+pub use escrow::*;
 pub use nonce::*;
 pub use signature_verifier::*;
 pub use stablecoin_dex::*;
@@ -43,3 +45,4 @@ pub const ADDRESS_REGISTRY_ADDRESS: Address =
     address!("0xFDC0000000000000000000000000000000000000");
 pub const SIGNATURE_VERIFIER_ADDRESS: Address =
     address!("0x5165300000000000000000000000000000000000");
+pub const ESCROW_ADDRESS: Address = address!("0xE5C0000000000000000000000000000000000000");

crates/contracts/src/precompiles/tip403_registry.rs

@@ -13,6 +13,12 @@ crate::sol! {
             COMPOUND
         }
 
+        enum BlockedReason {
+            NONE,
+            TOKEN_FILTER,
+            RECEIVE_POLICY
+        }
+
         // View Functions
         function policyIdCounter() external view returns (uint64);
         function policyExists(uint64 policyId) external view returns (bool);
@@ -22,6 +28,8 @@ crate::sol! {
         function isAuthorizedRecipient(uint64 policyId, address user) external view returns (bool);
         function isAuthorizedMintRecipient(uint64 policyId, address user) external view returns (bool);
         function compoundPolicyData(uint64 policyId) external view returns (uint64 senderPolicyId, uint64 recipientPolicyId, uint64 mintRecipientPolicyId);
+        function receivePolicy(address account) external view returns (bool hasReceivePolicy, uint64 senderPolicyId, PolicyType senderPolicyType, uint64 tokenFilterId, PolicyType tokenFilterType, address recoveryAddress);
+        function validateReceivePolicy(address token, address sender, address receiver) external view returns (bool authorized, BlockedReason blockedReason);
 
         // State-Changing Functions
         function createPolicy(address admin, PolicyType policyType) external returns (uint64);
@@ -30,13 +38,15 @@ crate::sol! {
         function modifyPolicyWhitelist(uint64 policyId, address account, bool allowed) external;
         function modifyPolicyBlacklist(uint64 policyId, address account, bool restricted) external;
         function createCompoundPolicy(uint64 senderPolicyId, uint64 recipientPolicyId, uint64 mintRecipientPolicyId) external returns (uint64);
+        function setReceivePolicy(uint64 senderPolicyId, uint64 tokenFilterId, address recoveryAddress) external;
 
         // Events
         event PolicyAdminUpdated(uint64 indexed policyId, address indexed updater, address indexed admin);
         event PolicyCreated(uint64 indexed policyId, address indexed updater, PolicyType policyType);
         event WhitelistUpdated(uint64 indexed policyId, address indexed updater, address indexed account, bool allowed);
         event BlacklistUpdated(uint64 indexed policyId, address indexed updater, address indexed account, bool restricted);
         event CompoundPolicyCreated(uint64 indexed policyId, address indexed creator, uint64 senderPolicyId, uint64 recipientPolicyId, uint64 mintRecipientPolicyId);
+        event ReceivePolicyUpdated(address indexed account, uint64 senderPolicyId, uint64 tokenFilterId, address recoveryAddress);
 
         // Errors
         error Unauthorized();
@@ -45,6 +55,8 @@ crate::sol! {
         error InvalidPolicyType();
         error IncompatiblePolicyType();
         error VirtualAddressNotAllowed();
+        error InvalidReceivePolicyType();
+        error InvalidReceivePolicyAddress();
     }
 }
 
@@ -94,4 +106,12 @@ impl TIP403RegistryError {
     pub const fn virtual_address_not_allowed() -> Self {
         Self::VirtualAddressNotAllowed(ITIP403Registry::VirtualAddressNotAllowed {})
     }
+
+    pub const fn invalid_receive_policy_type() -> Self {
+        Self::InvalidReceivePolicyType(ITIP403Registry::InvalidReceivePolicyType {})
+    }
+
+    pub const fn invalid_receive_policy_address() -> Self {
+        Self::InvalidReceivePolicyAddress(ITIP403Registry::InvalidReceivePolicyAddress {})
+    }
 }

crates/e2e/src/tests/mod.rs

@@ -18,6 +18,7 @@ mod snapshot;
 // FIXME: subblocks are currently flaky.
 // mod subblocks;
 mod sync;
+mod tip1028_escrow;
 mod v4_at_genesis;
 
 #[test_traced]