From 48ae9ebec52c8ab1c345afbd68f832ccc5e2ff6a Mon Sep 17 00:00:00 2001 From: 0age <37939117+0age@users.noreply.github.com> Date: Fri, 4 Oct 2024 12:09:02 -0700 Subject: [PATCH] add batch (one failing test) --- foundry.toml | 3 +- src/TheCompact.sol | 140 +++++++++++++++++++++++++++++++++-- src/interfaces/IOracle.sol | 6 ++ src/lib/EfficiencyLib.sol | 38 ++++++++++ src/lib/IdLib.sol | 118 +++++------------------------ src/lib/MetadataLib.sol | 105 ++++++++++++++++++++++++++ src/lib/MetadataRenderer.sol | 13 ++++ src/types/EIP712Types.sol | 35 +++++++++ test/TheCompact.t.sol | 140 ++++++++++++++++++++++++++++++++++- 9 files changed, 491 insertions(+), 107 deletions(-) create mode 100644 src/lib/EfficiencyLib.sol create mode 100644 src/lib/MetadataLib.sol create mode 100644 src/lib/MetadataRenderer.sol diff --git a/foundry.toml b/foundry.toml index 0e51f5d..6ab4400 100644 --- a/foundry.toml +++ b/foundry.toml @@ -2,8 +2,7 @@ solc = '0.8.27' evm_version='cancun' via_ir = true -# optimizer_runs = 4_294_967_295 # turn this back on after making the compact more compact -optimizer_runs = 200 +optimizer_runs = 4_294_967_295 bytecode_hash = 'none' src = "src" out = "out" diff --git a/src/TheCompact.sol b/src/TheCompact.sol index 2788889..1aef2d6 100644 --- a/src/TheCompact.sol +++ b/src/TheCompact.sol @@ -4,6 +4,8 @@ pragma solidity ^0.8.27; import { Lock } from "./types/Lock.sol"; import { IdLib } from "./lib/IdLib.sol"; import { ConsumerLib } from "./lib/ConsumerLib.sol"; +import { EfficiencyLib } from "./lib/EfficiencyLib.sol"; +import { MetadataLib } from "./lib/MetadataLib.sol"; import { ERC6909 } from "solady/tokens/ERC6909.sol"; import { FixedPointMathLib } from "solady/utils/FixedPointMathLib.sol"; import { SafeTransferLib } from "solady/utils/SafeTransferLib.sol"; @@ -13,8 +15,12 @@ import { ISignatureTransfer } from "permit2/src/interfaces/ISignatureTransfer.so import { Allocation, AllocationAuthorization, + BatchAllocation, + BatchAllocationAuthorization, ALLOCATION_TYPEHASH, ALLOCATION_AUTHORIZATION_TYPEHASH, + BATCH_ALLOCATION_TYPEHASH, + BATCH_ALLOCATION_AUTHORIZATION_TYPEHASH, TRANSFER_AUTHORIZATION_TYPEHASH, DELEGATED_TRANSFER_TYPEHASH, WITHDRAWAL_AUTHORIZATION_TYPEHASH, @@ -22,6 +28,7 @@ import { } from "./types/EIP712Types.sol"; import { IOracle } from "./interfaces/IOracle.sol"; import { IAllocator } from "./interfaces/IAllocator.sol"; +import { MetadataRenderer } from "./lib/MetadataRenderer.sol"; /** * @title The Compact @@ -35,10 +42,13 @@ contract TheCompact is ERC6909 { using IdLib for uint256; using IdLib for address; using IdLib for Lock; + using MetadataLib for address; using ConsumerLib for uint256; using SafeTransferLib for address; using SignatureCheckerLib for address; using FixedPointMathLib for uint256; + using EfficiencyLib for bool; + using EfficiencyLib for uint256; event Deposit( address indexed depositor, @@ -48,8 +58,8 @@ contract TheCompact is ERC6909 { ); event Claim( address indexed provider, - address indexed allocator, address indexed claimant, + uint256 indexed id, bytes32 allocationHash, uint256 claimAmount ); @@ -76,6 +86,7 @@ contract TheCompact is ERC6909 { error InvalidAmountReduction(uint256 amount, uint256 amountReduction); error UnallocatedTransfer(address from, address to, uint256 id, uint256 amount); error CallerNotClaimant(); + error InvalidBatchAllocation(); IPermit2 private constant _PERMIT2 = IPermit2(0x000000000022D473030F116dDEE9F6B43aC78BA3); @@ -106,12 +117,14 @@ contract TheCompact is ERC6909 { uint256 private immutable _INITIAL_CHAIN_ID; bytes32 private immutable _INITIAL_DOMAIN_SEPARATOR; + MetadataRenderer private immutable _METADATA_RENDERER; constructor() { _INITIAL_CHAIN_ID = block.chainid; _INITIAL_DOMAIN_SEPARATOR = keccak256( abi.encode(_DOMAIN_TYPEHASH, _NAME_HASH, _VERSION_HASH, block.chainid, address(this)) ); + _METADATA_RENDERER = new MetadataRenderer(); } /// @dev Returns the name for the contract. @@ -136,7 +149,7 @@ contract TheCompact is ERC6909 { /// @dev Returns the Uniform Resource Identifier (URI) for token `id`. function tokenURI(uint256 id) public view virtual override returns (string memory) { - return id.toURI(); + return _METADATA_RENDERER.uri(id.toLock(), id); } function deposit(address allocator, uint48 resetPeriod, address recipient) @@ -230,6 +243,32 @@ contract TheCompact is ERC6909 { _release(allocation.owner, claimant, allocation.id, claimAmount); } + function claim( + BatchAllocation calldata batchAllocation, + BatchAllocationAuthorization calldata batchAllocationAuthorization, + bytes calldata oracleVariableData, + bytes calldata ownerSignature, + bytes calldata allocatorSignature + ) external returns (address claimant, uint256[] memory claimAmounts) { + (claimant, claimAmounts) = _processBatchClaim( + batchAllocation, + batchAllocationAuthorization, + oracleVariableData, + ownerSignature, + allocatorSignature + ); + + + uint256 totalIds = batchAllocation.ids.length; + address owner = batchAllocation.owner; + unchecked { + for (uint256 i = 0; i < totalIds; ++i) { + // TODO: skip bounds checks on array accesses + _release(owner, claimant, batchAllocation.ids[i], claimAmounts[i]); + } + } + } + // Note: this can be frontrun since anyone can call claim function claimAndWithdraw( Allocation calldata allocation, @@ -290,7 +329,61 @@ contract TheCompact is ERC6909 { oracleClaimAmount.min(allocation.amount - allocationAuthorization.amountReduction); } - emit Claim(allocation.owner, allocator, claimant, allocationMessageHash, claimAmount); + emit Claim(allocation.owner, claimant, allocation.id, allocationMessageHash, claimAmount); + } + + function _processBatchClaim( + BatchAllocation calldata batchAllocation, + BatchAllocationAuthorization calldata batchAllocationAuthorization, + bytes calldata oracleVariableData, + bytes calldata ownerSignature, + bytes calldata allocatorSignature + ) internal returns (address claimant, uint256[] memory claimAmounts) { + _assertValidTime(batchAllocation.startTime, batchAllocation.endTime); + _assertValidTime(batchAllocationAuthorization.startTime, batchAllocationAuthorization.endTime); + + uint256 totalIds = batchAllocation.ids.length; + if ( + (totalIds == 0).or(totalIds != batchAllocation.amounts.length).or(totalIds != batchAllocationAuthorization.amountReductions.length) + ) { + revert InvalidBatchAllocation(); + } + + // TODO: skip the bounds check on this array access + uint256 allocatorIndex = batchAllocation.ids[0].toAllocatorIndex(); + claimAmounts = new uint256[](totalIds); + + address allocator = allocatorIndex.toRegisteredAllocator(); + batchAllocation.nonce.consumeNonce(allocator); + bytes32 batchAllocationMessageHash = _getBatchAllocationMessageHash(batchAllocation); + _assertValidSignature(batchAllocationMessageHash, ownerSignature, batchAllocation.owner); + bytes32 batchAllocationAuthorizationMessageHash = + _getBatchAllocationAuthorizationMessageHash(batchAllocationAuthorization, batchAllocationMessageHash); + _assertValidSignature(batchAllocationAuthorizationMessageHash, allocatorSignature, allocator); + (address oracleClaimant, uint256[] memory oracleClaimAmounts) = IOracle(batchAllocation.oracle).attestBatch( + batchAllocationMessageHash, batchAllocation.oracleFixedData, oracleVariableData + ); + + claimant = + _deriveClaimant(batchAllocation.claimant, batchAllocationAuthorization.claimant, oracleClaimant); + + // TODO: many of the bounds checks on these array accesses can be skipped as an optimization + uint256 errorBuffer = (batchAllocationAuthorization.amountReductions[0] >= batchAllocation.amounts[0]).or(totalIds != oracleClaimAmounts.length).asUint256(); + unchecked { + for (uint256 i = 1; i < totalIds; ++i) { + uint256 id = batchAllocation.ids[i]; + uint256 originalAmount = batchAllocation.amounts[i]; + uint256 amountReduction = batchAllocationAuthorization.amountReductions[i]; + errorBuffer |= (amountReduction >= originalAmount).or(id.toAllocatorIndex() != allocatorIndex).asUint256(); + uint256 claimAmount = oracleClaimAmounts[i].min(originalAmount - amountReduction); + claimAmounts[i] = claimAmount; + emit Claim(batchAllocation.owner, claimant, id, batchAllocationMessageHash, claimAmount); + } + } + if (errorBuffer.asBool()) { + // TODO: extract more informative error by deriving the reason for the failure + revert InvalidBatchAllocation(); + } } function enableForcedWithdrawal(uint256 id) external returns (uint256 withdrawableAt) { @@ -317,7 +410,7 @@ contract TheCompact is ERC6909 { { uint256 withdrawableAt = cutoffTime[msg.sender][id]; - if (withdrawableAt == 0 || withdrawableAt > block.timestamp) { + if ((withdrawableAt == 0).or(withdrawableAt > block.timestamp)) { revert PrematureWithdrawal(id); } @@ -440,7 +533,7 @@ contract TheCompact is ERC6909 { } function getAllocatorByIndex(uint256 index) external view returns (address) { - return index.registeredAllocatorByIndex(); + return index.toRegisteredAllocator(); } function getAllocatorIndex(address allocator) external view returns (uint256) { @@ -732,6 +825,27 @@ contract TheCompact is ERC6909 { ); } + function _getBatchAllocationMessageHash(BatchAllocation memory batchAllocation) + internal + pure + returns (bytes32 messageHash) + { + messageHash = keccak256( + abi.encode( + BATCH_ALLOCATION_TYPEHASH, + batchAllocation.owner, + batchAllocation.startTime, + batchAllocation.endTime, + batchAllocation.nonce, + keccak256(abi.encode(batchAllocation.ids)), + keccak256(abi.encode(batchAllocation.amounts)), + batchAllocation.claimant, + batchAllocation.oracle, + keccak256(batchAllocation.oracleFixedData) + ) + ); + } + function _getAllocationAuthorizationMessageHash( AllocationAuthorization memory allocationAuthorization, bytes32 allocationMessageHash @@ -748,6 +862,22 @@ contract TheCompact is ERC6909 { ); } + function _getBatchAllocationAuthorizationMessageHash( + BatchAllocationAuthorization memory batchAllocationAuthorization, + bytes32 batchAllocationMessageHash + ) internal pure returns (bytes32 messageHash) { + messageHash = keccak256( + abi.encode( + BATCH_ALLOCATION_AUTHORIZATION_TYPEHASH, + batchAllocationMessageHash, + batchAllocationAuthorization.startTime, + batchAllocationAuthorization.endTime, + batchAllocationAuthorization.claimant, + keccak256(abi.encode(batchAllocationAuthorization.amountReductions)) + ) + ); + } + function _getAuthorizedTransferMessageHash( uint256 expiration, uint256 nonce, diff --git a/src/interfaces/IOracle.sol b/src/interfaces/IOracle.sol index d3e7a11..61d8568 100644 --- a/src/interfaces/IOracle.sol +++ b/src/interfaces/IOracle.sol @@ -2,7 +2,13 @@ pragma solidity ^0.8.27; interface IOracle { + // Called on claims referencing a single allocated token. function attest(bytes32 allocationHash, bytes calldata fixedData, bytes calldata variableData) external returns (address claimant, uint256 claimAmount); + + // Called on claims referencing an array of allocated tokens. + function attestBatch(bytes32 allocationHash, bytes calldata fixedData, bytes calldata variableData) + external + returns (address claimant, uint256[] memory claimAmounts); } diff --git a/src/lib/EfficiencyLib.sol b/src/lib/EfficiencyLib.sol new file mode 100644 index 0000000..3de4c4e --- /dev/null +++ b/src/lib/EfficiencyLib.sol @@ -0,0 +1,38 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.27; + +library EfficiencyLib { + // NOTE: this function is only safe if the supplied booleans are known to not + // have any dirty bits set (i.e. they are either 0 or 1). It is meant to get + // around the fact that solidity only evaluates both expressions in an && if + // the first expression evaluates to true, which requires a conditional jump. + function and(bool a, bool b) internal pure returns (bool c) { + assembly { + c := and(a, b) + } + } + + // NOTE: this function is only safe if the supplied booleans are known to not + // have any dirty bits set (i.e. they are either 0 or 1). It is meant to get + // around the fact that solidity only evaluates both expressions in an || if + // the first expression evaluates to false, which requires a conditional jump. + function or(bool a, bool b) internal pure returns (bool c) { + assembly { + c := or(a, b) + } + } + + // NOTE: this function is only safe if the supplied uint256 is known to not + // have any dirty bits set (i.e. it is either 0 or 1). + function asBool(uint256 a) internal pure returns (bool b) { + assembly { + b := a + } + } + + function asUint256(bool a) internal pure returns (uint256 b) { + assembly { + b := a + } + } +} \ No newline at end of file diff --git a/src/lib/IdLib.sol b/src/lib/IdLib.sol index 32c5cce..eacc5d0 100644 --- a/src/lib/IdLib.sol +++ b/src/lib/IdLib.sol @@ -2,14 +2,12 @@ pragma solidity ^0.8.27; import { Lock } from "../types/Lock.sol"; -import { LibString } from "solady/utils/LibString.sol"; -import { MetadataReaderLib } from "solady/utils/MetadataReaderLib.sol"; +import { MetadataLib } from "./MetadataLib.sol"; library IdLib { - using LibString for uint256; - using LibString for address; - using MetadataReaderLib for address; using IdLib for address; + using IdLib for uint256; + using MetadataLib for Lock; event AllocatorRegistered(uint256 index, address allocator); @@ -30,97 +28,12 @@ library IdLib { return (id << 0x30) >> 0xd0; } - function toAllocator(uint256 id) internal view returns (address allocator) { - allocator = registeredAllocatorByIndex(id >> 0xd0); - } - - function toURI(uint256 id) internal view returns (string memory uri) { - Lock memory lock = toLock(id); - string memory tokenAddress = - lock.token == address(0) ? "Native Token" : lock.token.toHexStringChecksummed(); - string memory allocator = lock.allocator.toHexStringChecksummed(); - string memory resetPeriod = string.concat(lock.resetPeriod.toString(), " seconds"); - string memory tokenName = lock.token.readNameWithDefaultValue(); - string memory tokenSymbol = lock.token.readSymbolWithDefaultValue(); - string memory tokenDecimals = uint256(lock.token.readDecimals()).toString(); - - string memory name = string.concat("{\"name\": \"Compact ", tokenSymbol, "\","); - string memory description = string.concat( - "\"description\": \"Compact ", - tokenName, - " (", - tokenAddress, - ") with allocator ", - allocator, - " and reset period of ", - resetPeriod, - "\"," - ); - string memory attributes = string.concat( - "\"attributes\": [", - toAttributeString("Token Address", tokenAddress, false), - toAttributeString("Token Name", tokenName, false), - toAttributeString("Token Symbol", tokenSymbol, false), - toAttributeString("Token Decimals", tokenDecimals, false), - toAttributeString("Allocator", allocator, false), - toAttributeString("Reset Period", resetPeriod, true), - "]}" - ); - - // Note: this just returns a default image; replace with a dynamic image based on attributes - string memory image = - "\"image\": \"data:image/svg+xml;base64,<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Generator: Adobe Illustrator 23.0.5, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
	 viewBox="0 0 492 492" style="enable-background:new 0 0 492 492;" xml:space="preserve">
<g id="Master_Layer_2">
</g>
<g id="Layer_1">
	<g>
		<g>
			<g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M321.308,294.864c5.352,5.328,9.456,12.144,15.792,8.832
						c2.448-1.272,5.064-3.096,7.32-5.256c3.744-3.576,8.256-9.528,4.656-14.28c-12.456-11.976-36.384-32.112-36.456-32.16
						l7.56-8.568c0.024,0.024,5.16,4.536,11.832,10.824c8.688,8.208,20.856,16.2,26.736,24.408
						c3.312,4.608,2.616,12.744,0.864,17.52c-1.392,3.84-4.104,7.464-7.32,10.536c-3.024,2.904-6.6,5.4-9.96,7.128
						c-3.384,1.752-6.792,2.76-9.696,2.784c-0.096,0.456-0.216,0.936-0.336,1.392c-0.96,3.24-3.024,6.072-5.616,8.4
						c-2.328,2.088-5.136,3.816-7.944,5.064c-3.072,1.344-6.288,2.112-9.168,2.16c-0.096,0.936-0.288,1.848-0.552,2.76
						c-0.96,3.24-3.024,6.072-5.616,8.4c-2.328,2.088-5.136,3.816-7.944,5.064c-4.128,1.824-8.544,2.568-12,1.968
						c-0.12,1.224-0.36,2.4-0.696,3.504v0.024c-1.032,3.384-3,6.24-5.52,8.352c-2.52,2.112-5.592,3.48-8.856,3.936
						c-3.96,0.552-8.16-0.24-11.904-2.688c-1.032-0.672-2.16-1.536-3.48-2.592l-0.744-0.576l-11.16-8.616l6.96-9.024l11.16,8.616
						l0.744,0.576c1.032,0.792,1.896,1.488,2.784,2.04c1.296,0.864,2.736,1.128,4.08,0.96c1.128-0.168,2.184-0.648,3.072-1.392
						c0.864-0.72,1.56-1.728,1.92-2.904l0,0c0.456-1.56,0.384-3.504-0.456-5.76c-9.528-13.296-29.448-29.424-29.496-29.472
						l7.2-8.856c0.048,0.024,8.112,6.576,16.752,15.024c2.304,2.256,4.848,4.752,7.512,7.128c0.48,0.432,0.984,0.864,1.464,1.296
						l0,0l0,0c0.096,0.096,0.216,0.192,0.312,0.288c0.624,0.552,1.248,1.128,1.872,1.704c2.112,1.896,4.2,3.816,6.384,5.496
						c2.592,1.848,2.544,2.232,5.496,1.344c0.624-0.192,1.296-0.528,2.016-0.84c1.776-0.768,3.504-1.848,4.896-3.096
						c1.128-1.032,1.992-2.112,2.304-3.168c0.24-0.84,0.072-1.848-0.744-2.976c-9.576-13.32-35.904-36.456-35.976-36.528l7.56-8.568
						c0.048,0.048,14.688,12.912,26.616,25.488c3.24,3.192,8.064,7.56,11.544,10.272c1.272,0.912,2.16,2.088,4.08,1.416
						c0.816-0.288,1.848-0.696,3-1.2c1.776-0.768,3.504-1.848,4.896-3.096c1.128-1.008,1.992-2.112,2.304-3.168
						c0.24-0.84,0.072-1.848-0.744-3c-9.576-13.32-35.904-36.456-35.976-36.528l7.56-8.568
						C292.22,266.688,309.044,281.496,321.308,294.864z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M429.02,254.424L393.692,129.72l-1.536-5.448l-5.448,1.488
						l-45.216,12.408l-5.568,1.536l1.56,5.52l2.136,7.536c-21.696,1.968-42.84-2.664-62.568-6.96
						c-39.264-8.568-73.296-15.984-99.576,25.896l0,0c-7.104,11.352-14.856,24.84-16.656,35.16
						c-2.472,14.04,3.024,23.04,25.248,18.96c13.656-2.496,22.08-9.36,29.928-15.768c8.88-7.248,16.872-13.752,32.376-9.144
						c8.136,3.36,8.88,3.672,15.24,9.024c21.144,17.736,71.4,61.536,72,62.04l0,0l10.416,9.168l2.904,2.544l3.432-1.752
						l20.88-10.608l1.272,4.488l5.472-1.56l45.096-12.768l5.496-1.56L429.02,254.424L429.02,254.424z M350.636,269.976l-7.512-6.6
						H343.1c-0.144-0.12-51.624-45-72.192-62.232c-7.704-6.456-8.568-6.816-18.36-10.872l-0.24-0.096l-0.528-0.192
						c-21.36-6.456-31.608,1.92-42.984,11.208c-6.768,5.52-13.992,11.424-24.768,13.392c-10.08,1.848-12.768-1.032-11.928-5.784
						c1.488-8.472,8.544-20.664,15.048-31.056v-0.024c21.96-35.064,52.392-28.44,87.48-20.784
						c21.192,4.608,43.944,9.576,68.16,6.936l27.264,96.24L350.636,269.976L350.636,269.976z M382.364,261.696L350.06,147.625
						l34.2-9.384l32.232,113.784L382.364,261.696z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M155.013,145.2l-2.28,8.016
						c10.224,0.216,29.592,0.048,45.72-3.6l2.496,11.136c-18.96,4.296-41.808,4.104-51.408,3.792l-25.488,89.976
						c9.672,3.048,27.888,10.968,29.352,27.72l-11.4,0.984c-0.888-10.152-13.728-15.504-21.072-17.76l-1.368,4.824l-1.56,5.496
						l-5.472-1.56l-45.096-12.768l-5.496-1.56l1.56-5.472l35.328-124.704l1.536-5.448l5.448,1.488l45.216,12.408l5.568,1.536
						L155.013,145.2L155.013,145.2L155.013,145.2z M110.157,261.696l32.304-114.072l-34.2-9.384L76.029,252.024L110.157,261.696z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M240.764,336.672L240.764,336.672
						c-1.104-0.816-2.448-1.08-3.744-0.888s-2.496,0.864-3.312,1.944l-8.832,11.976h0.024c-0.816,1.104-1.104,2.472-0.912,3.744
						c0.192,1.272,0.864,2.472,1.944,3.288l0.168,0.144c1.056,0.72,2.352,0.96,3.576,0.768c1.296-0.192,2.496-0.864,3.312-1.944
						l8.856-12c0.816-1.104,1.08-2.448,0.888-3.744C242.516,338.688,241.844,337.488,240.764,336.672L240.764,336.672
						L240.764,336.672z M176.421,266.28c4.224,3.12,6.816,7.68,7.536,12.504c0.312,2.064,0.288,4.176-0.096,6.24
						c1.896-0.96,3.936-1.608,6.024-1.92c5.016-0.744,10.296,0.384,14.688,3.624v0.024c4.416,3.24,7.08,7.968,7.824,12.984
						c0.312,1.992,0.288,4.032-0.024,6.048c0.6-0.144,1.176-0.264,1.776-0.36c4.536-0.672,9.336,0.36,13.296,3.288l0.288,0.24
						c3.816,2.928,6.144,7.128,6.816,11.52c0.216,1.368,0.264,2.76,0.144,4.152c0.216-0.048,0.408-0.072,0.624-0.096
						c4.128-0.624,8.544,0.336,12.192,3.024l0,0c3.672,2.712,5.88,6.624,6.504,10.776c0.624,4.128-0.336,8.544-3.048,12.192
						l-8.856,12c-2.712,3.672-6.624,5.88-10.776,6.504c-4.128,0.624-8.52-0.336-12.192-3.024v0.024
						c-3.648-2.688-5.88-6.624-6.504-10.8c-0.072-0.48-0.12-0.96-0.144-1.44c-1.008,0.336-2.04,0.6-3.072,0.744
						c-4.512,0.672-9.312-0.36-13.296-3.312l0,0c-3.984-2.952-6.408-7.224-7.08-11.736c-0.144-0.912-0.216-1.824-0.192-2.76
						c-1.512,0.624-3.072,1.08-4.68,1.32c-5.016,0.744-10.296-0.384-14.688-3.624l0,0c-4.392-3.24-7.08-7.992-7.824-13.008
						c-0.384-2.472-0.288-5.016,0.312-7.488c-1.584,0.72-3.264,1.2-4.968,1.464c-4.824,0.72-9.912-0.384-14.136-3.48
						c-4.224-3.12-6.816-7.68-7.536-12.504s0.384-9.912,3.48-14.136h0.024l10.992-14.904c3.12-4.248,7.68-6.816,12.48-7.536
						C167.085,262.056,172.173,263.16,176.421,266.28L176.421,266.28L176.421,266.28L176.421,266.28z M172.653,280.464
						c-0.288-1.944-1.32-3.768-2.976-4.992v-0.024c-1.68-1.224-3.72-1.656-5.688-1.368c-1.968,0.288-3.792,1.32-5.016,2.976
						l-10.992,14.88h0.024c-1.248,1.68-1.68,3.744-1.392,5.688c0.288,1.944,1.32,3.768,2.976,4.992
						c1.68,1.248,3.744,1.68,5.688,1.392s3.768-1.32,4.992-2.976l0.024,0l10.992-14.88h-0.024
						C172.485,284.472,172.941,282.408,172.653,280.464L172.653,280.464L172.653,280.464z M201.092,301.416
						c-0.312-2.136-1.44-4.152-3.264-5.496v0.024c-1.848-1.368-4.104-1.848-6.24-1.536c-2.16,0.336-4.152,1.44-5.52,3.264
						l-11.616,15.744c-1.344,1.848-1.824,4.104-1.512,6.24c0.312,2.136,1.44,4.128,3.264,5.496l0,0
						c1.848,1.368,4.104,1.848,6.24,1.536c2.16-0.312,4.152-1.44,5.52-3.264l0,0l11.616-15.744
						C200.948,305.832,201.428,303.576,201.092,301.416L201.092,301.416L201.092,301.416z M223.244,322.152
						c-0.24-1.68-1.104-3.24-2.52-4.272v0.024c-1.44-1.056-3.192-1.44-4.848-1.176c-1.656,0.24-3.216,1.104-4.248,2.544l-0.192,0.24
						l-9.888,13.416v0.024c-1.056,1.416-1.416,3.168-1.152,4.824c0.264,1.68,1.128,3.24,2.544,4.272l0,0
						c1.416,1.056,3.168,1.416,4.848,1.152c1.68-0.264,3.24-1.128,4.272-2.544L222.141,327
						C223.124,325.584,223.508,323.832,223.244,322.152z"/>
				</g>
			</g>
		</g>
	</g>
</g>
</svg>
\","; - - uri = string.concat(name, description, image, attributes); - } - - function readNameWithDefaultValue(address token) internal view returns (string memory name) { - // NOTE: this will not take into account the correct symbol on many chains - if (token == address(0)) { - return "Ether"; - } - - name = token.readName(); - if (bytes(name).length == 0) { - name = "unknown token"; - } - } - - function readSymbolWithDefaultValue(address token) - internal - view - returns (string memory symbol) - { - // NOTE: this will not take into account the correct symbol on many chains - if (token == address(0)) { - return "ETH"; - } - - symbol = token.readSymbol(); - if (bytes(symbol).length == 0) { - symbol = "???"; - } + function toAllocatorIndex(uint256 id) internal pure returns (uint256 index) { + index = id >> 0xd0; } - function readDecimalsWithDefaultValue(address token) - internal - view - returns (string memory decimals) - { - if (token == address(0)) { - return "18"; - } - return uint256(token.readDecimals()).toString(); - } - - function toAttributeString(string memory trait, string memory value, bool terminal) - internal - pure - returns (string memory attribute) - { - return string.concat( - "{\"trait_type\": \"", trait, "\", \"value\": \"", value, "\"}", terminal ? "" : "," - ); + function toAllocator(uint256 id) internal view returns (address allocator) { + allocator = id.toAllocatorIndex().toRegisteredAllocator(); } function toLock(address token, address allocator, uint48 resetPeriod) @@ -132,15 +45,22 @@ library IdLib { } function toLock(uint256 id) internal view returns (Lock memory lock) { - lock.token = toToken(id); - lock.resetPeriod = toResetPeriod(id); - lock.allocator = toAllocator(id); + lock.token = id.toToken(); + lock.resetPeriod = id.toResetPeriod(); + lock.allocator = id.toAllocator(); } function toId(Lock memory lock) internal returns (uint256 id) { id = ( uint256(uint160(lock.token)) | ((lock.resetPeriod << 0xd0) >> 0x30) - | toIndex(lock.allocator) << 0xd0 + | lock.allocator.toIndex() << 0xd0 + ); + } + + function toIdIfRegistered(Lock memory lock) internal view returns (uint256 id) { + id = ( + uint256(uint160(lock.token)) | ((lock.resetPeriod << 0xd0) >> 0x30) + | lock.allocator.toIndexIfRegistered() << 0xd0 ); } @@ -150,7 +70,7 @@ library IdLib { } } - function registeredAllocatorByIndex(uint256 index) internal view returns (address allocator) { + function toRegisteredAllocator(uint256 index) internal view returns (address allocator) { assembly { allocator := sload(or(_ALLOCATOR_BY_INDEX_SLOT_SEED, index)) diff --git a/src/lib/MetadataLib.sol b/src/lib/MetadataLib.sol new file mode 100644 index 0000000..77db604 --- /dev/null +++ b/src/lib/MetadataLib.sol @@ -0,0 +1,105 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.27; + +import { Lock } from "../types/Lock.sol"; +import { IdLib } from "./IdLib.sol"; +import { LibString } from "solady/utils/LibString.sol"; +import { MetadataReaderLib } from "solady/utils/MetadataReaderLib.sol"; + +library MetadataLib { + using MetadataLib for address; + using MetadataLib for string; + using IdLib for Lock; + using LibString for uint256; + using LibString for address; + using MetadataReaderLib for address; + + function toURI(Lock memory lock, uint256 id) internal view returns (string memory uri) { + string memory tokenAddress = + lock.token == address(0) ? "Native Token" : lock.token.toHexStringChecksummed(); + string memory allocator = lock.allocator.toHexStringChecksummed(); + string memory resetPeriod = string.concat(lock.resetPeriod.toString(), " seconds"); + string memory tokenName = lock.token.readNameWithDefaultValue(); + string memory tokenSymbol = lock.token.readSymbolWithDefaultValue(); + string memory tokenDecimals = uint256(lock.token.readDecimals()).toString(); + + string memory name = string.concat("{\"name\": \"Compact ", tokenSymbol, "\","); + string memory description = string.concat( + "\"description\": \"Compact ", + tokenName, + " (", + tokenAddress, + ") with allocator ", + allocator, + " and reset period of ", + resetPeriod, + "\"," + ); + string memory attributes = string.concat( + "\"attributes\": [", + toAttributeString("ID", id.toString(), false), + toAttributeString("Token Address", tokenAddress, false), + toAttributeString("Token Name", tokenName, false), + toAttributeString("Token Symbol", tokenSymbol, false), + toAttributeString("Token Decimals", tokenDecimals, false), + toAttributeString("Allocator", allocator, false), + toAttributeString("Reset Period", resetPeriod, true), + "]}" + ); + + // Note: this just returns a default image; replace with a dynamic image based on attributes + string memory image = + "\"image\": \"data:image/svg+xml;base64,<?xml version="1.0" encoding="iso-8859-1"?>
<!-- Generator: Adobe Illustrator 23.0.5, SVG Export Plug-In . SVG Version: 6.00 Build 0)  -->
<svg version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" x="0px" y="0px"
	 viewBox="0 0 492 492" style="enable-background:new 0 0 492 492;" xml:space="preserve">
<g id="Master_Layer_2">
</g>
<g id="Layer_1">
	<g>
		<g>
			<g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M321.308,294.864c5.352,5.328,9.456,12.144,15.792,8.832
						c2.448-1.272,5.064-3.096,7.32-5.256c3.744-3.576,8.256-9.528,4.656-14.28c-12.456-11.976-36.384-32.112-36.456-32.16
						l7.56-8.568c0.024,0.024,5.16,4.536,11.832,10.824c8.688,8.208,20.856,16.2,26.736,24.408
						c3.312,4.608,2.616,12.744,0.864,17.52c-1.392,3.84-4.104,7.464-7.32,10.536c-3.024,2.904-6.6,5.4-9.96,7.128
						c-3.384,1.752-6.792,2.76-9.696,2.784c-0.096,0.456-0.216,0.936-0.336,1.392c-0.96,3.24-3.024,6.072-5.616,8.4
						c-2.328,2.088-5.136,3.816-7.944,5.064c-3.072,1.344-6.288,2.112-9.168,2.16c-0.096,0.936-0.288,1.848-0.552,2.76
						c-0.96,3.24-3.024,6.072-5.616,8.4c-2.328,2.088-5.136,3.816-7.944,5.064c-4.128,1.824-8.544,2.568-12,1.968
						c-0.12,1.224-0.36,2.4-0.696,3.504v0.024c-1.032,3.384-3,6.24-5.52,8.352c-2.52,2.112-5.592,3.48-8.856,3.936
						c-3.96,0.552-8.16-0.24-11.904-2.688c-1.032-0.672-2.16-1.536-3.48-2.592l-0.744-0.576l-11.16-8.616l6.96-9.024l11.16,8.616
						l0.744,0.576c1.032,0.792,1.896,1.488,2.784,2.04c1.296,0.864,2.736,1.128,4.08,0.96c1.128-0.168,2.184-0.648,3.072-1.392
						c0.864-0.72,1.56-1.728,1.92-2.904l0,0c0.456-1.56,0.384-3.504-0.456-5.76c-9.528-13.296-29.448-29.424-29.496-29.472
						l7.2-8.856c0.048,0.024,8.112,6.576,16.752,15.024c2.304,2.256,4.848,4.752,7.512,7.128c0.48,0.432,0.984,0.864,1.464,1.296
						l0,0l0,0c0.096,0.096,0.216,0.192,0.312,0.288c0.624,0.552,1.248,1.128,1.872,1.704c2.112,1.896,4.2,3.816,6.384,5.496
						c2.592,1.848,2.544,2.232,5.496,1.344c0.624-0.192,1.296-0.528,2.016-0.84c1.776-0.768,3.504-1.848,4.896-3.096
						c1.128-1.032,1.992-2.112,2.304-3.168c0.24-0.84,0.072-1.848-0.744-2.976c-9.576-13.32-35.904-36.456-35.976-36.528l7.56-8.568
						c0.048,0.048,14.688,12.912,26.616,25.488c3.24,3.192,8.064,7.56,11.544,10.272c1.272,0.912,2.16,2.088,4.08,1.416
						c0.816-0.288,1.848-0.696,3-1.2c1.776-0.768,3.504-1.848,4.896-3.096c1.128-1.008,1.992-2.112,2.304-3.168
						c0.24-0.84,0.072-1.848-0.744-3c-9.576-13.32-35.904-36.456-35.976-36.528l7.56-8.568
						C292.22,266.688,309.044,281.496,321.308,294.864z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M429.02,254.424L393.692,129.72l-1.536-5.448l-5.448,1.488
						l-45.216,12.408l-5.568,1.536l1.56,5.52l2.136,7.536c-21.696,1.968-42.84-2.664-62.568-6.96
						c-39.264-8.568-73.296-15.984-99.576,25.896l0,0c-7.104,11.352-14.856,24.84-16.656,35.16
						c-2.472,14.04,3.024,23.04,25.248,18.96c13.656-2.496,22.08-9.36,29.928-15.768c8.88-7.248,16.872-13.752,32.376-9.144
						c8.136,3.36,8.88,3.672,15.24,9.024c21.144,17.736,71.4,61.536,72,62.04l0,0l10.416,9.168l2.904,2.544l3.432-1.752
						l20.88-10.608l1.272,4.488l5.472-1.56l45.096-12.768l5.496-1.56L429.02,254.424L429.02,254.424z M350.636,269.976l-7.512-6.6
						H343.1c-0.144-0.12-51.624-45-72.192-62.232c-7.704-6.456-8.568-6.816-18.36-10.872l-0.24-0.096l-0.528-0.192
						c-21.36-6.456-31.608,1.92-42.984,11.208c-6.768,5.52-13.992,11.424-24.768,13.392c-10.08,1.848-12.768-1.032-11.928-5.784
						c1.488-8.472,8.544-20.664,15.048-31.056v-0.024c21.96-35.064,52.392-28.44,87.48-20.784
						c21.192,4.608,43.944,9.576,68.16,6.936l27.264,96.24L350.636,269.976L350.636,269.976z M382.364,261.696L350.06,147.625
						l34.2-9.384l32.232,113.784L382.364,261.696z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M155.013,145.2l-2.28,8.016
						c10.224,0.216,29.592,0.048,45.72-3.6l2.496,11.136c-18.96,4.296-41.808,4.104-51.408,3.792l-25.488,89.976
						c9.672,3.048,27.888,10.968,29.352,27.72l-11.4,0.984c-0.888-10.152-13.728-15.504-21.072-17.76l-1.368,4.824l-1.56,5.496
						l-5.472-1.56l-45.096-12.768l-5.496-1.56l1.56-5.472l35.328-124.704l1.536-5.448l5.448,1.488l45.216,12.408l5.568,1.536
						L155.013,145.2L155.013,145.2L155.013,145.2z M110.157,261.696l32.304-114.072l-34.2-9.384L76.029,252.024L110.157,261.696z"/>
				</g>
				<g>
					<path style="fill-rule:evenodd;clip-rule:evenodd;fill:#212121;" d="M240.764,336.672L240.764,336.672
						c-1.104-0.816-2.448-1.08-3.744-0.888s-2.496,0.864-3.312,1.944l-8.832,11.976h0.024c-0.816,1.104-1.104,2.472-0.912,3.744
						c0.192,1.272,0.864,2.472,1.944,3.288l0.168,0.144c1.056,0.72,2.352,0.96,3.576,0.768c1.296-0.192,2.496-0.864,3.312-1.944
						l8.856-12c0.816-1.104,1.08-2.448,0.888-3.744C242.516,338.688,241.844,337.488,240.764,336.672L240.764,336.672
						L240.764,336.672z M176.421,266.28c4.224,3.12,6.816,7.68,7.536,12.504c0.312,2.064,0.288,4.176-0.096,6.24
						c1.896-0.96,3.936-1.608,6.024-1.92c5.016-0.744,10.296,0.384,14.688,3.624v0.024c4.416,3.24,7.08,7.968,7.824,12.984
						c0.312,1.992,0.288,4.032-0.024,6.048c0.6-0.144,1.176-0.264,1.776-0.36c4.536-0.672,9.336,0.36,13.296,3.288l0.288,0.24
						c3.816,2.928,6.144,7.128,6.816,11.52c0.216,1.368,0.264,2.76,0.144,4.152c0.216-0.048,0.408-0.072,0.624-0.096
						c4.128-0.624,8.544,0.336,12.192,3.024l0,0c3.672,2.712,5.88,6.624,6.504,10.776c0.624,4.128-0.336,8.544-3.048,12.192
						l-8.856,12c-2.712,3.672-6.624,5.88-10.776,6.504c-4.128,0.624-8.52-0.336-12.192-3.024v0.024
						c-3.648-2.688-5.88-6.624-6.504-10.8c-0.072-0.48-0.12-0.96-0.144-1.44c-1.008,0.336-2.04,0.6-3.072,0.744
						c-4.512,0.672-9.312-0.36-13.296-3.312l0,0c-3.984-2.952-6.408-7.224-7.08-11.736c-0.144-0.912-0.216-1.824-0.192-2.76
						c-1.512,0.624-3.072,1.08-4.68,1.32c-5.016,0.744-10.296-0.384-14.688-3.624l0,0c-4.392-3.24-7.08-7.992-7.824-13.008
						c-0.384-2.472-0.288-5.016,0.312-7.488c-1.584,0.72-3.264,1.2-4.968,1.464c-4.824,0.72-9.912-0.384-14.136-3.48
						c-4.224-3.12-6.816-7.68-7.536-12.504s0.384-9.912,3.48-14.136h0.024l10.992-14.904c3.12-4.248,7.68-6.816,12.48-7.536
						C167.085,262.056,172.173,263.16,176.421,266.28L176.421,266.28L176.421,266.28L176.421,266.28z M172.653,280.464
						c-0.288-1.944-1.32-3.768-2.976-4.992v-0.024c-1.68-1.224-3.72-1.656-5.688-1.368c-1.968,0.288-3.792,1.32-5.016,2.976
						l-10.992,14.88h0.024c-1.248,1.68-1.68,3.744-1.392,5.688c0.288,1.944,1.32,3.768,2.976,4.992
						c1.68,1.248,3.744,1.68,5.688,1.392s3.768-1.32,4.992-2.976l0.024,0l10.992-14.88h-0.024
						C172.485,284.472,172.941,282.408,172.653,280.464L172.653,280.464L172.653,280.464z M201.092,301.416
						c-0.312-2.136-1.44-4.152-3.264-5.496v0.024c-1.848-1.368-4.104-1.848-6.24-1.536c-2.16,0.336-4.152,1.44-5.52,3.264
						l-11.616,15.744c-1.344,1.848-1.824,4.104-1.512,6.24c0.312,2.136,1.44,4.128,3.264,5.496l0,0
						c1.848,1.368,4.104,1.848,6.24,1.536c2.16-0.312,4.152-1.44,5.52-3.264l0,0l11.616-15.744
						C200.948,305.832,201.428,303.576,201.092,301.416L201.092,301.416L201.092,301.416z M223.244,322.152
						c-0.24-1.68-1.104-3.24-2.52-4.272v0.024c-1.44-1.056-3.192-1.44-4.848-1.176c-1.656,0.24-3.216,1.104-4.248,2.544l-0.192,0.24
						l-9.888,13.416v0.024c-1.056,1.416-1.416,3.168-1.152,4.824c0.264,1.68,1.128,3.24,2.544,4.272l0,0
						c1.416,1.056,3.168,1.416,4.848,1.152c1.68-0.264,3.24-1.128,4.272-2.544L222.141,327
						C223.124,325.584,223.508,323.832,223.244,322.152z"/>
				</g>
			</g>
		</g>
	</g>
</g>
</svg>
\","; + + uri = string.concat(name, description, image, attributes); + } + + function readNameWithDefaultValue(address token) internal view returns (string memory name) { + // NOTE: this will not take into account the correct symbol on many chains + if (token == address(0)) { + return "Ether"; + } + + name = token.readName(); + if (bytes(name).length == 0) { + name = "unknown token"; + } + } + + function readSymbolWithDefaultValue(address token) + internal + view + returns (string memory symbol) + { + // NOTE: this will not take into account the correct symbol on many chains + if (token == address(0)) { + return "ETH"; + } + + symbol = token.readSymbol(); + if (bytes(symbol).length == 0) { + symbol = "???"; + } + } + + function readDecimalsWithDefaultValue(address token) + internal + view + returns (string memory decimals) + { + if (token == address(0)) { + return "18"; + } + return uint256(token.readDecimals()).toString(); + } + + function toAttributeString(string memory trait, string memory value, bool terminal) + internal + pure + returns (string memory attribute) + { + return string.concat( + "{\"trait_type\": \"", trait, "\", \"value\": \"", value, "\"}", terminal ? "" : "," + ); + } +} \ No newline at end of file diff --git a/src/lib/MetadataRenderer.sol b/src/lib/MetadataRenderer.sol new file mode 100644 index 0000000..7f28ae5 --- /dev/null +++ b/src/lib/MetadataRenderer.sol @@ -0,0 +1,13 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.27; + +import { MetadataLib } from "./MetadataLib.sol"; +import { Lock } from "../types/Lock.sol"; + +contract MetadataRenderer { + using MetadataLib for Lock; + + function uri(Lock memory lock, uint256 id) external view returns (string memory) { + return lock.toURI(id); + } +} \ No newline at end of file diff --git a/src/types/EIP712Types.sol b/src/types/EIP712Types.sol index 51e0bad..e4538d1 100644 --- a/src/types/EIP712Types.sol +++ b/src/types/EIP712Types.sol @@ -20,6 +20,26 @@ struct Allocation { bytes32 constant ALLOCATION_TYPEHASH = 0x332b96efcdc96931e9c671e47db4a873af3efa03557c9c2b93f4eb5f85587c15; + +// Message signed by the owner that specifies the conditions under which a set of +// tokens can be allocated; the specified oracle verifies that those conditions +// have been met, enabling an allocatee to claim the specified token amounts. +struct BatchAllocation { + address owner; // The account to source the allocation from. + uint256 startTime; // The time at which the allocation can be released. + uint256 endTime; // The time at which the allocation expires. + uint256 nonce; // A parameter to enforce replay protection, scoped to allocator. + uint256[] ids; // The token IDs to allocate, ordered sequentially by token address & sharing a single allocator. + uint256[] amounts; // The amounts of each ERC6909 token to allocate. + address claimant; // The allocation recipient (no address: any recipient) + address oracle; // The account enforcing whether to release allocated funds. + bytes oracleFixedData; // The fixed data payload provided to the oracle. +} + +// keccak256("BatchAllocation(address owner,uint256 startTime,uint256 endTime,uint256 nonce,uint256[] ids,uint256[] amounts,address claimant,address oracle,bytes oracleFixedData)") +bytes32 constant BATCH_ALLOCATION_TYPEHASH = + 0x4a861c73d7d12b2f376a12be983a2d1f530af97e12d5ff0b5f8e9d790ee09b93; + // Message signed by the allocator that confirms that a given allocation does // not result in an over-allocated state for the token owner, and that modifies // the conditions of the allocation where applicable. @@ -35,6 +55,21 @@ struct AllocationAuthorization { bytes32 constant ALLOCATION_AUTHORIZATION_TYPEHASH = 0x9d7957a907b00fac8de3a22c078f7f0409c40a085d5c51f7a371cf3291563692; +// Message signed by the allocator that confirms that a given allocation does +// not result in an over-allocated state for the token owner, and that modifies +// the conditions of the allocation where applicable. +struct BatchAllocationAuthorization { + // bytes32 allocationHash; // signed but not explicitly supplied as a parameter + uint256 startTime; // The time at which the allocation authorization becomes valid. + uint256 endTime; // The time at which the allocation authorization expires. + address claimant; // The allocation recipient (no address: any recipient) + uint256[] amountReductions; // The amounts by which each claimable token will be reduced. +} + +// keccak256("BatchAllocationAuthorization(bytes32 allocationHash,uint256 startTime,uint256 endTime,address claimant,uint256[] amountReductions)") +bytes32 constant BATCH_ALLOCATION_AUTHORIZATION_TYPEHASH = + 0x4c90cb61ec8a1c2fae08542cc7898d379b30b0aa4a2a31eb94f4942bf3b3e59a; + // Message signed by the allocator that confirms that a given withdrawal does // not result in an over-allocated state for the token owner, and that enables // the owner to directly withdraw their tokens to an arbitrary recipient. diff --git a/test/TheCompact.t.sol b/test/TheCompact.t.sol index 4dc78b1..aba43ca 100644 --- a/test/TheCompact.t.sol +++ b/test/TheCompact.t.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.13; import { Test, console } from "forge-std/Test.sol"; import { TheCompact } from "../src/TheCompact.sol"; import { MockERC20 } from "../lib/solady/test/utils/mocks/MockERC20.sol"; -import { Allocation, AllocationAuthorization } from "../src/types/EIP712Types.sol"; +import { Allocation, AllocationAuthorization, BatchAllocation, BatchAllocationAuthorization } from "../src/types/EIP712Types.sol"; interface EIP712 { function DOMAIN_SEPARATOR() external view returns (bytes32); @@ -13,12 +13,14 @@ interface EIP712 { contract TheCompactTest is Test { TheCompact public theCompact; MockERC20 public token; + MockERC20 public anotherToken; address permit2 = address(0x000000000022D473030F116dDEE9F6B43aC78BA3); uint256 swapperPrivateKey; address swapper; uint256 allocatorPrivateKey; address allocator; address dummyOracle; + address dummyBatchOracle; bytes32 compactEIP712DomainHash = keccak256( "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)" ); @@ -27,6 +29,7 @@ contract TheCompactTest is Test { function setUp() public { address deployedDummyOracle; + address deployedDummyBatchOracle; assembly { // deploy a contract that always returns one word of 0's followed by one word of f's // minimal "constructor" 0x600b5981380380925939f3... (11 bytes) @@ -41,8 +44,15 @@ contract TheCompactTest is Test { // F3 RETURN [] (Returns 0x40 bytes from memory starting at 0x00) mstore(0, 0x600b5981380380925939f360403d3d19602052f3) deployedDummyOracle := create(0, 12, 20) + + // and this one returns [0, 0x40, 3, 0xfff, 0xfff, 0xfff] + mstore(0, 0x600b598138038092) + mstore(0x20, 0x5939f360c03d60406020600360403d1960603d1960803d1960a05252525252f3) + deployedDummyBatchOracle := create(0, 24, 40) } dummyOracle = deployedDummyOracle; + dummyBatchOracle = deployedDummyBatchOracle; + address permit2Deployer = address(0x4e59b44847b379578588920cA78FbF26c0B4956C); address deployedPermit2Deployer; address permit2DeployerDeployer = address(0x3fAB184622Dc19b6109349B94811493BF2a45362); @@ -65,16 +75,20 @@ contract TheCompactTest is Test { theCompact = new TheCompact(); token = new MockERC20("Mock ERC20", "MOCK", 18); + anotherToken = new MockERC20("Another Mock ERC20", "MOCK2", 18); (swapper, swapperPrivateKey) = makeAddrAndKey("swapper"); (allocator, allocatorPrivateKey) = makeAddrAndKey("allocator"); vm.deal(swapper, 2e18); token.mint(swapper, 1e18); + anotherToken.mint(swapper, 1e18); vm.startPrank(swapper); token.approve(address(theCompact), 1e18); token.approve(permit2, 1e18); + anotherToken.approve(address(theCompact), 1e18); + anotherToken.approve(permit2, 1e18); vm.stopPrank(); } @@ -564,6 +578,8 @@ contract TheCompactTest is Test { address allocatorClaimant = claimant; uint256 amountReduction = 0; + uint256 anotherAmountReduction = 0; + uint256 aThirdAmountReduction = 0; vm.prank(swapper); uint256 id = theCompact.deposit{ value: amount }(allocator, resetPeriod, swapper); @@ -639,4 +655,126 @@ contract TheCompactTest is Test { assertEq(theCompact.balanceOf(claimant, id), 0); assertEq(theCompact.balanceOf(recipient, id), 0); } + + function test_batchClaim() public { + uint48 resetPeriod = 120; + uint256 amount = 1e18; + uint256 anotherAmount = 1e18; + uint256 aThirdAmount = 1e18; + uint256 nonce = 0; + uint256 startTime = block.timestamp; + uint256 endTime = block.timestamp + 1000; + address claimant = 0x1111111111111111111111111111111111111111; + address oracle = dummyBatchOracle; + bytes memory oracleFixedData; + bytes memory oracleVariableData; + + address allocatorClaimant = claimant; + uint256 amountReduction = 0; + uint256 anotherAmountReduction = 0; + uint256 aThirdAmountReduction = 0; + + vm.startPrank(swapper); + uint256 id = theCompact.deposit{ value: amount }(allocator, resetPeriod, swapper); + + uint256 anotherId = theCompact.deposit(address(token), allocator, resetPeriod, anotherAmount, swapper); + assertEq(theCompact.balanceOf(swapper, id), anotherAmount); + + uint256 aThirdId = theCompact.deposit(address(anotherToken), allocator, resetPeriod, aThirdAmount, swapper); + assertEq(theCompact.balanceOf(swapper, id), aThirdAmount); + + vm.stopPrank(); + + assertEq(theCompact.balanceOf(swapper, id), amount); + assertEq(theCompact.balanceOf(swapper, anotherId), anotherAmount); + assertEq(theCompact.balanceOf(swapper, aThirdId), aThirdAmount); + + uint256[] memory ids = new uint256[](3); + ids[0] = id; + ids[1] = anotherId; + ids[2] = aThirdId; + + uint256[] memory amounts = new uint256[](3); + amounts[0] = amount; + amounts[1] = anotherAmount; + amounts[2] = aThirdAmount; + + uint256[] memory amountReductions = new uint256[](3); + amountReductions[0] = amountReduction; + amountReductions[1] = anotherAmountReduction; + amountReductions[2] = aThirdAmountReduction; + + bytes32 allocationHash = keccak256( + abi.encode( + keccak256( + "BatchAllocation(address owner,uint256 startTime,uint256 endTime,uint256 nonce,uint256[] ids,uint256[] amounts,address claimant,address oracle,bytes oracleFixedData)" + ), + swapper, + startTime, + endTime, + nonce, + keccak256(abi.encode(ids)), + keccak256(abi.encode(amounts)), + claimant, + oracle, + keccak256(oracleFixedData) + ) + ); + + bytes32 digest = keccak256( + abi.encodePacked(bytes2(0x1901), theCompact.DOMAIN_SEPARATOR(), allocationHash) + ); + + (bytes32 r, bytes32 vs) = vm.signCompact(swapperPrivateKey, digest); + bytes memory ownerSignature = abi.encodePacked(r, vs); + + digest = keccak256( + abi.encodePacked( + bytes2(0x1901), + theCompact.DOMAIN_SEPARATOR(), + keccak256( + abi.encode( + keccak256( + "BatchAllocationAuthorization(bytes32 allocationHash,uint256 startTime,uint256 endTime,address claimant,uint256[] amountReductions)" + ), + allocationHash, + startTime, + endTime, + allocatorClaimant, + keccak256(abi.encode(amountReductions)) + ) + ) + ) + ); + + (r, vs) = vm.signCompact(allocatorPrivateKey, digest); + bytes memory allocatorSignature = abi.encodePacked(r, vs); + + BatchAllocation memory allocation = BatchAllocation( + swapper, startTime, endTime, nonce, ids, amounts, claimant, oracle, oracleFixedData + ); + BatchAllocationAuthorization memory allocationAuthorization = + BatchAllocationAuthorization(startTime, endTime, allocatorClaimant, amountReductions); + + (address returnedClaimant, uint256[] memory returnedClaimAmounts) = theCompact.claim( + allocation, + allocationAuthorization, + oracleVariableData, + ownerSignature, + allocatorSignature + ); + assertEq(claimant, returnedClaimant); + + for (uint256 i = 0; i < ids.length; ++i) { + assertEq(amounts[i], returnedClaimAmounts[i]); + } + + assertEq(address(theCompact).balance, amount); + assertEq(token.balanceOf(address(theCompact)), anotherAmount); + assertEq(anotherToken.balanceOf(address(theCompact)), aThirdAmount); + + assertEq(theCompact.balanceOf(claimant, id), amount); + assertEq(theCompact.balanceOf(claimant, anotherId), anotherAmount); + assertEq(theCompact.balanceOf(claimant, aThirdId), aThirdAmount); + } }