Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.
JavaScript 3d-generationai-agentsanimationavatardigital-humangenerative-aiglbgltfimage-to-3dllmmcpmcp-servermodel-context-protocolsolanatext-to-3dthreejsweb-componentswebglwebxrx402
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import {Test} from "forge-std/Test.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {GreenfieldVault} from "../src/GreenfieldVault.sol";
import {IPermissionHub} from "../src/greenfield/IPermissionHub.sol";
import {MockCrossChain, MockPermissionHub, MockGnfdAccessControl} from "./mocks/MockGreenfield.sol";
import {Reentrant} from "./mocks/Reentrant.sol";
/// @notice Counterparty with no `receive`, so any ETH the vault sends it fails.
/// Proves the payout-failure branches of `buy`, `revoke`, and
/// `withdraw` revert instead of silently discarding the credit.
contract EthRejector {
function doList(GreenfieldVault vault, bytes32 objectId, uint256 price) external {
vault.list(objectId, price, address(this));
}
function doBuy(GreenfieldVault vault, bytes32 objectId, bytes calldata policyData) external payable {
vault.buy{value: msg.value}(objectId, policyData);
}
function doRevoke(GreenfieldVault vault, uint256 saleId) external payable {
vault.revoke{value: msg.value}(saleId);
}
function doWithdraw(GreenfieldVault vault) external {
vault.withdraw();
}
}
/// @dev Invariants under proof: GV-1 .. GV-8 of
/// `specs/ECONOMY_CONTRACT_INVARIANTS.md`.
contract GreenfieldVaultTest is Test {
MockCrossChain internal crossChain;
MockPermissionHub internal permissionHub;
MockGnfdAccessControl internal accessControl;
GreenfieldVault internal vault;
address internal seller = makeAddr("seller");
address internal buyer = makeAddr("buyer");
address internal buyer2 = makeAddr("buyer2");
bytes32 internal constant OBJECT_ID = keccak256("three-ws/vault/object-1");
bytes32 internal constant OBJECT_ID_2 = keccak256("three-ws/vault/object-2");
uint256 internal constant PRICE = 1 ether;
uint256 internal constant RELAY_FEE = 0.001 ether;
uint256 internal constant ACK_RELAY_FEE = 0.0005 ether;
uint256 internal constant TOTAL_FEE = RELAY_FEE + ACK_RELAY_FEE;
uint256 internal constant TOTAL_REQUIRED = PRICE + TOTAL_FEE;
// Opaque stand-in for an off-chain-built Greenfield permission payload
// (real protobuf principal/resource/statements — see GreenfieldVault.buy natspec).
bytes internal constant POLICY_DATA = hex"0102030405";
uint32 internal constant STATUS_SUCCESS = 0;
uint32 internal constant STATUS_FAILED = 1;
event Listed(bytes32 indexed objectId, address indexed seller, uint256 price);
event Delisted(bytes32 indexed objectId, address indexed seller);
event Purchased(bytes32 indexed objectId, address indexed buyer, uint256 indexed saleId, uint256 price);
event PolicyGranted(bytes32 indexed objectId, address indexed buyer, uint256 indexed saleId, uint256 policyId);
event PolicyGrantFailed(bytes32 indexed objectId, address indexed buyer, uint256 indexed saleId, uint32 status);
event RevokeRequested(bytes32 indexed objectId, uint256 indexed saleId, uint256 policyId);
event Withdrawn(address indexed seller, uint256 amount);
function setUp() public {
crossChain = new MockCrossChain(RELAY_FEE, ACK_RELAY_FEE);
permissionHub = new MockPermissionHub(crossChain);
accessControl = new MockGnfdAccessControl();
vault = new GreenfieldVault(address(permissionHub), address(crossChain), address(accessControl));
vm.deal(seller, 10 ether);
vm.deal(buyer, 10 ether);
vm.deal(buyer2, 10 ether);
}
// ── helpers ──────────────────────────────────────────────────────────
function _grantRole(address _seller) internal {
bytes32 role = vault.ROLE_CREATE();
vm.prank(_seller);
accessControl.grantRole(role, address(vault), 0);
}
function _list(address _seller, bytes32 objectId, uint256 price) internal {
_grantRole(_seller);
vm.prank(_seller);
vault.list(objectId, price, _seller);
}
function _buy(address _buyer, bytes32 objectId) internal returns (uint256 saleId) {
vm.prank(_buyer);
saleId = vault.buy{value: TOTAL_REQUIRED}(objectId, POLICY_DATA);
}
// ── constructor ──────────────────────────────────────────────────────
function testConstructorRejectsZeroAddresses() public {
vm.expectRevert(GreenfieldVault.ZeroAddress.selector);
new GreenfieldVault(address(0), address(crossChain), address(accessControl));
vm.expectRevert(GreenfieldVault.ZeroAddress.selector);
new GreenfieldVault(address(permissionHub), address(0), address(accessControl));
vm.expectRevert(GreenfieldVault.ZeroAddress.selector);
new GreenfieldVault(address(permissionHub), address(crossChain), address(0));
}
// ── list / delist ────────────────────────────────────────────────────
function testListRequiresRoleGrant() public {
vm.prank(seller);
vm.expectRevert(GreenfieldVault.NotAuthorizedByObjectOwner.selector);
vault.list(OBJECT_ID, PRICE, seller);
}
function testListOnlySeller() public {
_grantRole(seller);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.OnlySeller.selector);
vault.list(OBJECT_ID, PRICE, seller);
}
function testListRejectsBadInput() public {
_grantRole(seller);
vm.startPrank(seller);
vm.expectRevert(GreenfieldVault.BadObjectId.selector);
vault.list(bytes32(0), PRICE, seller);
vm.expectRevert(GreenfieldVault.BadPrice.selector);
vault.list(OBJECT_ID, 0, seller);
vm.expectRevert(GreenfieldVault.ZeroAddress.selector);
vault.list(OBJECT_ID, PRICE, address(0));
vm.stopPrank();
}
function testListEmitsAndStores() public {
_grantRole(seller);
vm.prank(seller);
vm.expectEmit(true, true, false, true, address(vault));
emit Listed(OBJECT_ID, seller, PRICE);
vault.list(OBJECT_ID, PRICE, seller);
(address listedSeller, uint256 price, bool active) = vault.listings(OBJECT_ID);
assertEq(listedSeller, seller);
assertEq(price, PRICE);
assertTrue(active);
}
function testRelistBySameSellerUpdatesPrice() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(seller);
vault.list(OBJECT_ID, PRICE * 2, seller);
(, uint256 price,) = vault.listings(OBJECT_ID);
assertEq(price, PRICE * 2);
}
function testListByAnotherSellerReverts() public {
_list(seller, OBJECT_ID, PRICE);
_grantRole(buyer);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.ListedByAnotherSeller.selector);
vault.list(OBJECT_ID, PRICE, buyer);
}
function testDelist() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(seller);
vm.expectEmit(true, true, false, true, address(vault));
emit Delisted(OBJECT_ID, seller);
vault.delist(OBJECT_ID);
(,, bool active) = vault.listings(OBJECT_ID);
assertFalse(active);
}
function testDelistOnlySeller() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.OnlySeller.selector);
vault.delist(OBJECT_ID);
}
function testDelistNotListedReverts() public {
vm.expectRevert(GreenfieldVault.NotListed.selector);
vault.delist(OBJECT_ID);
}
// ── buy ──────────────────────────────────────────────────────────────
function testBuyHappyPathAndSettlement() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(buyer);
vm.expectEmit(true, true, true, true, address(vault));
emit Purchased(OBJECT_ID, buyer, 1, PRICE);
uint256 saleId = vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
assertEq(saleId, 1);
assertEq(vault.pendingWithdrawals(seller), 0);
assertEq(vault.saleIdOf(OBJECT_ID, buyer), 1);
(
bytes32 objId,
address buy_,
address sell_,
uint256 price_,
uint256 policyId_,
GreenfieldVault.SaleStatus status_
) = vault.sales(1);
assertEq(objId, OBJECT_ID);
assertEq(buy_, buyer);
assertEq(sell_, seller);
assertEq(price_, PRICE);
assertEq(policyId_, 0);
assertEq(uint8(status_), uint8(GreenfieldVault.SaleStatus.Pending));
// Simulate the real Greenfield relayer settling the ack.
vm.expectEmit(true, true, true, true, address(vault));
emit PolicyGranted(OBJECT_ID, buyer, 1, 1);
permissionHub.settleCreatePolicy(1, STATUS_SUCCESS);
(,,,, uint256 policyIdAfter, GreenfieldVault.SaleStatus statusAfter) = vault.sales(1);
assertEq(policyIdAfter, 1);
assertEq(uint8(statusAfter), uint8(GreenfieldVault.SaleStatus.Granted));
}
function testBuyUnlistedReverts() public {
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.NotListed.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
}
function testBuyEmptyPolicyDataReverts() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.EmptyPolicyData.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, "");
}
function testBuyUnderpaymentReverts() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.InsufficientPayment.selector);
vault.buy{value: TOTAL_REQUIRED - 1}(OBJECT_ID, POLICY_DATA);
}
function testBuyMissingCrossChainFeeReverts() public {
_list(seller, OBJECT_ID, PRICE);
// Pays the exact list price but covers none of the relay fee.
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.InsufficientPayment.selector);
vault.buy{value: PRICE}(OBJECT_ID, POLICY_DATA);
}
function testBuyDoesNotHalfExecuteOnUnderpayment() public {
_list(seller, OBJECT_ID, PRICE);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.InsufficientPayment.selector);
vault.buy{value: PRICE}(OBJECT_ID, POLICY_DATA);
// Nothing was recorded: no sale, no pending withdrawal, no saleIdOf entry.
assertEq(vault.nextSaleId(), 1);
assertEq(vault.pendingWithdrawals(seller), 0);
assertEq(vault.saleIdOf(OBJECT_ID, buyer), 0);
}
function testBuyRefundsExcessPayment() public {
_list(seller, OBJECT_ID, PRICE);
uint256 overpay = TOTAL_REQUIRED + 0.5 ether;
uint256 before = buyer.balance;
vm.prank(buyer);
vault.buy{value: overpay}(OBJECT_ID, POLICY_DATA);
assertEq(buyer.balance, before - TOTAL_REQUIRED);
}
/// GV-2 (negative half): a (objectId, buyer) pair may not buy twice while
/// a purchase is open. The retry-after-failure and resell-after-revoke
/// halves are proven by testSettlementFailureAllowsRetry and
/// testRevokeHappyPath.
function testDoubleBuySameBuyerReverts() public {
_list(seller, OBJECT_ID, PRICE);
_buy(buyer, OBJECT_ID);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.AlreadyPurchased.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
}
/// GV-2 (positive half): distinct buyers are independent pairs and may
/// each hold an open purchase on the same object.
function testDifferentBuyersCanEachPurchase() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId1 = _buy(buyer, OBJECT_ID);
uint256 saleId2 = _buy(buyer2, OBJECT_ID);
assertTrue(saleId1 != saleId2);
permissionHub.settleCreatePolicy(saleId1, STATUS_SUCCESS);
permissionHub.settleCreatePolicy(saleId2, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(seller), PRICE * 2);
}
function testSettlementFailureAllowsRetry() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
vm.expectEmit(true, true, true, true, address(vault));
emit PolicyGrantFailed(OBJECT_ID, buyer, saleId, STATUS_FAILED);
permissionHub.settleCreatePolicy(saleId, STATUS_FAILED);
(,,,,, GreenfieldVault.SaleStatus status) = vault.sales(saleId);
assertEq(uint8(status), uint8(GreenfieldVault.SaleStatus.Failed));
assertEq(vault.saleIdOf(OBJECT_ID, buyer), 0);
// Buyer can now retry.
uint256 saleId2 = _buy(buyer, OBJECT_ID);
assertTrue(saleId2 != saleId);
}
// ── GV-10: proceeds are escrowed until Greenfield confirms the grant ────
function testSellerNotCreditedUntilGrantSettles() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
assertEq(vault.pendingWithdrawals(seller), 0, "no credit while the ack is pending");
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(seller), PRICE, "credited on confirmed grant");
}
function testGrantFailureRefundsBuyerAndNeverPaysSeller() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
// The seller revokes the role the vault needs before Greenfield acks.
bytes32 role = vault.ROLE_CREATE();
vm.prank(seller);
accessControl.revokeRole(role, address(vault));
permissionHub.settleCreatePolicy(saleId, STATUS_FAILED);
assertEq(vault.pendingWithdrawals(seller), 0, "seller earns nothing from a failed grant");
assertEq(vault.pendingWithdrawals(buyer), PRICE, "buyer's price is refundable");
vm.prank(seller);
vm.expectRevert(GreenfieldVault.NothingToWithdraw.selector);
vault.withdraw();
uint256 before = buyer.balance;
vm.prank(buyer);
vault.withdraw();
assertEq(buyer.balance, before + PRICE);
}
function testRepeatedSettlementDoesNotDoubleCredit() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
vm.prank(address(permissionHub));
vault.greenfieldCall(STATUS_FAILED, 0x07, 2, 1, abi.encode(saleId));
vm.prank(address(permissionHub));
vault.greenfieldCall(STATUS_SUCCESS, 0x07, 2, 1, abi.encode(saleId));
assertEq(vault.pendingWithdrawals(seller), PRICE);
assertEq(vault.pendingWithdrawals(buyer), 0);
}
function testBuyRevertsWhenSellerRevokedRoleAfterListing() public {
_list(seller, OBJECT_ID, PRICE);
bytes32 role = vault.ROLE_CREATE();
vm.prank(seller);
accessControl.revokeRole(role, address(vault));
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.NotAuthorizedByObjectOwner.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
}
// ── GV-6: greenfieldCall access control ────────────────────────────────
/// GV-6 (negative half): only the PermissionHub contract may deliver an ack.
function testGreenfieldCallOnlyPermissionHub() public {
vm.expectRevert(GreenfieldVault.OnlyPermissionHub.selector);
vault.greenfieldCall(STATUS_SUCCESS, 0x07, 2, 1, abi.encode(uint256(1)));
}
/// GV-6 (negative half): only the permission channel is accepted.
function testGreenfieldCallBadChannelReverts() public {
vm.prank(address(permissionHub));
vm.expectRevert(GreenfieldVault.BadChannel.selector);
vault.greenfieldCall(STATUS_SUCCESS, 0x05, 2, 1, abi.encode(uint256(1)));
}
/// GV-6 (negative half): an ack for a sale that does not exist reverts.
function testGreenfieldCallUnknownSaleReverts() public {
vm.prank(address(permissionHub));
vm.expectRevert(GreenfieldVault.UnknownSale.selector);
vault.greenfieldCall(STATUS_SUCCESS, 0x07, 2, 999, abi.encode(uint256(999)));
}
// ── GV-9: a declined hub request is never treated as accepted ──────────
/// GV-9 (negative half): `createPolicy` returning false (the hub declining
/// without reverting) unwinds the whole purchase. Nothing is credited to the
/// seller, no sale id is retained, and the buyer keeps their money.
function testBuyRevertsWhenHubDeclinesCreatePolicy() public {
_list(seller, OBJECT_ID, PRICE);
permissionHub.setRejectOnCreate(true);
uint256 buyerBalanceBefore = buyer.balance;
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.PolicyRequestRejected.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
assertEq(buyer.balance, buyerBalanceBefore);
assertEq(vault.pendingWithdrawals(seller), 0);
assertEq(vault.saleIdOf(OBJECT_ID, buyer), 0);
assertEq(address(vault).balance, 0);
}
/// GV-9 (positive half): once the hub stops declining, the same buyer can
/// purchase normally, so the rejection left no poisoned state behind.
function testBuySucceedsAfterHubStopsDeclining() public {
_list(seller, OBJECT_ID, PRICE);
permissionHub.setRejectOnCreate(true);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.PolicyRequestRejected.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, POLICY_DATA);
permissionHub.setRejectOnCreate(false);
uint256 saleId = _buy(buyer, OBJECT_ID);
assertEq(vault.saleIdOf(OBJECT_ID, buyer), saleId);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(seller), PRICE);
}
/// GV-9 (negative half, revoke side): `deletePolicy` returning false leaves
/// the sale Granted rather than marking it Revoked while the buyer still
/// holds a live Greenfield grant.
function testRevokeRevertsWhenHubDeclinesDeletePolicy() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
permissionHub.setRejectOnDelete(true);
vm.prank(seller);
vm.expectRevert(GreenfieldVault.PolicyRequestRejected.selector);
vault.revoke{value: TOTAL_FEE}(saleId);
(,,,,, GreenfieldVault.SaleStatus status) = vault.sales(saleId);
assertEq(uint8(status), uint8(GreenfieldVault.SaleStatus.Granted));
assertEq(vault.saleIdOf(OBJECT_ID, buyer), saleId);
}
// ── revoke ───────────────────────────────────────────────────────────
function testRevokeHappyPath() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
vm.prank(seller);
vm.expectEmit(true, true, false, true, address(vault));
emit RevokeRequested(OBJECT_ID, saleId, saleId); // policyId == saleId here (both start at 1)
vault.revoke{value: TOTAL_FEE}(saleId);
(,,,,, GreenfieldVault.SaleStatus status) = vault.sales(saleId);
assertEq(uint8(status), uint8(GreenfieldVault.SaleStatus.Revoked));
assertEq(vault.saleIdOf(OBJECT_ID, buyer), 0);
assertTrue(permissionHub.deletedPolicies(saleId));
// Buyer can be resold access.
uint256 saleId2 = _buy(buyer, OBJECT_ID);
assertTrue(saleId2 != saleId);
}
function testRevokeOnlySaleSeller() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.NotSaleSeller.selector);
vault.revoke{value: TOTAL_FEE}(saleId);
}
function testRevokeUnknownSaleReverts() public {
vm.prank(seller);
vm.expectRevert(GreenfieldVault.UnknownSale.selector);
vault.revoke{value: TOTAL_FEE}(999);
}
function testRevokeRequiresGrantedStatus() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
// Still Pending — never settled.
vm.prank(seller);
vm.expectRevert(GreenfieldVault.SaleNotGranted.selector);
vault.revoke{value: TOTAL_FEE}(saleId);
}
function testRevokeInsufficientFeeReverts() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
vm.prank(seller);
vm.expectRevert(GreenfieldVault.InsufficientRelayFee.selector);
vault.revoke{value: TOTAL_FEE - 1}(saleId);
}
function testRevokeRefundsExcessFee() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
uint256 before = seller.balance;
vm.prank(seller);
vault.revoke{value: TOTAL_FEE + 0.2 ether}(saleId);
assertEq(seller.balance, before - TOTAL_FEE);
}
// ── withdraw ─────────────────────────────────────────────────────────
function testWithdrawHappyPath() public {
_list(seller, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
uint256 before = seller.balance;
vm.prank(seller);
vm.expectEmit(true, false, false, true, address(vault));
emit Withdrawn(seller, PRICE);
uint256 amount = vault.withdraw();
assertEq(amount, PRICE);
assertEq(seller.balance, before + PRICE);
assertEq(vault.pendingWithdrawals(seller), 0);
}
function testWithdrawNothingReverts() public {
vm.prank(seller);
vm.expectRevert(GreenfieldVault.NothingToWithdraw.selector);
vault.withdraw();
}
/// GV-4: a seller that cannot receive ETH gets a revert, not a silent
/// zeroing of its credited balance.
function testWithdrawToARejectingSellerReverts() public {
EthRejector badSeller = new EthRejector();
bytes32 role = vault.ROLE_CREATE();
vm.prank(address(badSeller));
accessControl.grantRole(role, address(vault), 0);
badSeller.doList(vault, OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(address(badSeller)), PRICE);
vm.expectRevert(GreenfieldVault.TransferFailed.selector);
badSeller.doWithdraw(vault);
assertEq(vault.pendingWithdrawals(address(badSeller)), PRICE, "GV-4: the credit survives a failed payout");
}
/// GV-3: a buyer that cannot receive its refund gets a revert, so the
/// purchase never half-lands.
function testBuyRefundFailureRevertsTheWholePurchase() public {
_list(seller, OBJECT_ID, PRICE);
EthRejector badBuyer = new EthRejector();
vm.deal(address(badBuyer), 10 ether);
vm.expectRevert(GreenfieldVault.TransferFailed.selector);
badBuyer.doBuy{value: TOTAL_REQUIRED + 1 ether}(vault, OBJECT_ID, POLICY_DATA);
assertEq(vault.saleIdOf(OBJECT_ID, address(badBuyer)), 0, "GV-3: no sale may survive a failed refund");
assertEq(vault.pendingWithdrawals(seller), 0);
}
/// GV-7: same for a seller's excess relay fee on revoke.
function testRevokeRefundFailureReverts() public {
EthRejector badSeller = new EthRejector();
bytes32 role = vault.ROLE_CREATE();
vm.prank(address(badSeller));
accessControl.grantRole(role, address(vault), 0);
badSeller.doList(vault, OBJECT_ID, PRICE);
vm.deal(address(badSeller), 10 ether);
uint256 saleId = _buy(buyer, OBJECT_ID);
// Settle through the mock hub, not a pranked greenfieldCall: the hub
// must record the vault as the policy owner or its deletePolicy
// rejects the revoke before the refund path under test is reached.
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
vm.expectRevert(GreenfieldVault.TransferFailed.selector);
badSeller.doRevoke{value: TOTAL_FEE + 1 ether}(vault, saleId);
(,,,,, GreenfieldVault.SaleStatus status) = vault.sales(saleId);
assertEq(uint8(status), uint8(GreenfieldVault.SaleStatus.Granted), "the sale stays Granted");
}
// ── GV-5: the vault always holds enough to pay every seller ──────────────
function testVaultBalanceCoversEveryPendingWithdrawal() public {
_list(seller, OBJECT_ID, PRICE);
_list(seller, OBJECT_ID_2, 2 ether);
uint256 s1 = _buy(buyer, OBJECT_ID);
vm.prank(buyer2);
uint256 s2 = vault.buy{value: 2 ether + TOTAL_FEE}(OBJECT_ID_2, POLICY_DATA);
permissionHub.settleCreatePolicy(s1, STATUS_SUCCESS);
permissionHub.settleCreatePolicy(s2, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(seller), 3 ether);
assertGe(address(vault).balance, vault.pendingWithdrawals(seller), "GV-5: held ETH must cover every credit");
vm.prank(seller);
vault.withdraw();
assertGe(address(vault).balance, vault.pendingWithdrawals(seller));
}
// ── views ────────────────────────────────────────────────────────────
function testQuoteRelayFee() public view {
(uint256 relayFee, uint256 minAckRelayFee, uint256 total) = vault.quoteRelayFee();
assertEq(relayFee, RELAY_FEE);
assertEq(minAckRelayFee, ACK_RELAY_FEE);
assertEq(total, TOTAL_FEE);
}
// ── re-entrancy ──────────────────────────────────────────────────────
/// Proves `nonReentrant` blocks a *cross-function* reentrant call: an
/// attacker buying object A, whose refund callback tries to buy an
/// entirely separate, validly listed object B. Absent the guard this
/// nested `buy()` would succeed outright (B is listed, unpurchased, fully
/// funded) — instead the whole outer transaction reverts, proving the
/// lock (not incidental state) is what stopped it.
function testReentrantBuyBlocked() public {
_list(seller, OBJECT_ID, PRICE);
_list(seller, OBJECT_ID_2, PRICE);
Reentrant attacker = new Reentrant(vault);
vm.deal(address(attacker), 10 ether);
attacker.arm(abi.encodeWithSelector(GreenfieldVault.buy.selector, OBJECT_ID_2, POLICY_DATA), TOTAL_REQUIRED);
uint256 overpay = TOTAL_REQUIRED + TOTAL_REQUIRED; // enough refund to fund the nested attempt
// The outer buy() itself succeeds — the low-level refund call only
// reverts if the *callee* (receive()) reverts, and receive() swallows
// the nested call's failure via a low-level `.call`. What proves the
// guard fired is that the nested call captured inside `attacker`
// failed with exactly `ReentrancyGuardReentrantCall`.
attacker.doBuy{value: overpay}(OBJECT_ID, POLICY_DATA);
assertTrue(attacker.reentryAttempted());
assertFalse(attacker.reentryOk());
assertEq(bytes4(attacker.reentryReturnData()), ReentrancyGuard.ReentrancyGuardReentrantCall.selector);
// The nested buy never happened: object B is still unpurchased.
assertEq(vault.saleIdOf(OBJECT_ID_2, address(attacker)), 0);
}
/// Same proof against `withdraw()`: a malicious seller's payout callback
/// tries to re-enter `withdraw()` itself.
function testReentrantWithdrawBlocked() public {
Reentrant attacker = new Reentrant(vault);
bytes32 role = vault.ROLE_CREATE();
vm.prank(address(attacker));
accessControl.grantRole(role, address(vault), 0);
attacker.doList(OBJECT_ID, PRICE);
uint256 saleId = _buy(buyer, OBJECT_ID);
permissionHub.settleCreatePolicy(saleId, STATUS_SUCCESS);
assertEq(vault.pendingWithdrawals(address(attacker)), PRICE);
attacker.arm(abi.encodeWithSelector(GreenfieldVault.withdraw.selector), 0);
attacker.doWithdraw();
assertTrue(attacker.reentryAttempted());
assertFalse(attacker.reentryOk());
assertEq(bytes4(attacker.reentryReturnData()), ReentrancyGuard.ReentrancyGuardReentrantCall.selector);
}
// ── resource-bound listings ──────────────────────────────────────────
/// protobuf `greenfield.permission.Policy` for (principal, object resource id),
/// byte-for-byte what api/_lib/bnb/vault-policy-data.js emits for a lowercase buyer.
function _expectedPolicy(address who, string memory resourceId) internal pure returns (bytes memory) {
bytes memory hexChars = "0123456789abcdef";
bytes memory addr = new bytes(42);
addr[0] = "0";
addr[1] = "x";
uint160 v = uint160(who);
for (uint256 i = 0; i < 20; i++) {
uint8 b = uint8(v >> (8 * (19 - i)));
addr[2 + 2 * i] = hexChars[b >> 4];
addr[3 + 2 * i] = hexChars[b & 0x0f];
}
return abi.encodePacked(
hex"0a0130122e0801122a", addr, hex"180222", uint8(bytes(resourceId).length), resourceId, hex"2a050801120106"
);
}
function _listBound(address _seller, bytes32 objectId, string memory resourceId) internal {
_grantRole(_seller);
vm.prank(_seller);
vault.listBound(objectId, PRICE, _seller, resourceId);
}
function testBoundListingAcceptsOnlyThePolicyForItsResourceAndTheBuyer() public {
_listBound(seller, OBJECT_ID, "12345");
vm.prank(buyer);
uint256 saleId = vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, _expectedPolicy(buyer, "12345"));
assertEq(saleId, 1);
}
function testBoundListingRejectsPolicyForAnotherResource() public {
_listBound(seller, OBJECT_ID, "12345");
bytes memory other = _expectedPolicy(buyer, "99999");
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.PolicyDataMismatch.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, other);
}
function testBoundListingRejectsPolicyNamingAnotherPrincipal() public {
_listBound(seller, OBJECT_ID, "12345");
bytes memory forOther = _expectedPolicy(buyer2, "12345");
vm.prank(buyer);
vm.expectRevert(GreenfieldVault.PolicyDataMismatch.selector);
vault.buy{value: TOTAL_REQUIRED}(OBJECT_ID, forOther);
}
function testListBoundRejectsEmptyOrOversizedResourceId() public {
_grantRole(seller);
vm.startPrank(seller);
vm.expectRevert(GreenfieldVault.BadResourceId.selector);
vault.listBound(OBJECT_ID, PRICE, seller, "");
vm.expectRevert(GreenfieldVault.BadResourceId.selector);
vault.listBound(OBJECT_ID, PRICE, seller, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");
vm.stopPrank();
}
function testPlainRelistClearsAStaleResourceBinding() public {
_listBound(seller, OBJECT_ID, "12345");
vm.prank(seller);
vault.list(OBJECT_ID, PRICE, seller);
assertEq(bytes(vault.listingResourceId(OBJECT_ID)).length, 0);
}
}