d-bis/smom-dbis-138
4
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

refactor(archive): move historical contracts and adapters to archive directory

Browse Source 
- Archived multiple non-EVM adapters (Algorand, Hedera, Tron, TON, Cosmos, Solana) and compliance contracts (IndyVerifier) to `archive/solidity/contracts/`.
- Updated documentation to reflect the historical status of archived components.
- Adjusted `foundry.toml` and `README.md` for clarity on historical dependencies and configurations.
- Enhanced Makefile and package.json scripts for improved contract testing and building processes.
- Removed obsolete contracts (AlltraCustomBridge, CommodityCCIPBridge, ISO4217WCCIPBridge, VaultBridgeAdapter) from the main directory.
- Updated implementation reports to indicate archived status for various components.
This commit is contained in:
defiQUG
2026-04-12 18:21:05 -07:00
parent 8ec6af94d5
commit 2b52cc6e32
146 changed files with 2010 additions and 423 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
script/deploy/DeployAaveQuotePushFlashReceiver.s.sol
View File

@@ -11,6 +11,7 @@ import {AaveQuotePushFlashReceiver} from "../../contracts/flash/AaveQuotePushFla
* Env:
* PRIVATE_KEY required
* AAVE_POOL_ADDRESS optional; defaults to Aave V3 mainnet Pool
* QUOTE_PUSH_RECEIVER_OWNER optional; defaults to deployer derived from PRIVATE_KEY
*
* Usage:
* forge script script/deploy/DeployAaveQuotePushFlashReceiver.s.sol:DeployAaveQuotePushFlashReceiver \
@@ -23,12 +24,14 @@ contract DeployAaveQuotePushFlashReceiver is Script {
uint256 pk = vm.envUint("PRIVATE_KEY");
address pool = vm.envOr("AAVE_POOL_ADDRESS", DEFAULT_AAVE_POOL_MAINNET);
address deployer = vm.addr(pk);
address owner = vm.envOr("QUOTE_PUSH_RECEIVER_OWNER", deployer);
console.log("Deployer:", deployer);
console.log("Aave Pool:", pool);
console.log("Receiver owner:", owner);
vm.startBroadcast(pk);
AaveQuotePushFlashReceiver receiver = new AaveQuotePushFlashReceiver(pool);
AaveQuotePushFlashReceiver receiver = new AaveQuotePushFlashReceiver(pool, owner);
vm.stopBroadcast();
console.log("AaveQuotePushFlashReceiver:", address(receiver));

72
script/deploy/DeployQuotePushTreasuryManager.s.sol Normal file
View File

@@ -0,0 +1,72 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {AaveQuotePushFlashReceiver} from "../../contracts/flash/AaveQuotePushFlashReceiver.sol";
import {QuotePushTreasuryManager} from "../../contracts/flash/QuotePushTreasuryManager.sol";
/**
* @title DeployQuotePushTreasuryManager
* @notice Deploy a treasury manager for quote-push retained surplus and optionally
* hand receiver ownership to it in the same broadcast.
*
* Env:
* PRIVATE_KEY required
* AAVE_QUOTE_PUSH_RECEIVER_MAINNET required
* QUOTE_PUSH_SURPLUS_TOKEN_MAINNET optional; defaults to USDC mainnet
* QUOTE_PUSH_TREASURY_OWNER optional; defaults to deployer
* QUOTE_PUSH_TREASURY_OPERATOR optional; defaults to owner
* QUOTE_PUSH_TREASURY_GAS_RECIPIENT optional; defaults to owner
* QUOTE_PUSH_TREASURY_RECYCLE_RECIPIENT optional; defaults to owner
* QUOTE_PUSH_RECEIVER_RESERVE_RAW optional; defaults to 0
* QUOTE_PUSH_TREASURY_RESERVE_RAW optional; defaults to 0
* QUOTE_PUSH_TREASURY_TAKE_RECEIVER_OWNERSHIP optional; 1 to transfer receiver ownership to manager
*/
contract DeployQuotePushTreasuryManager is Script {
address internal constant DEFAULT_USDC_MAINNET = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function run() external {
uint256 pk = vm.envUint("PRIVATE_KEY");
address receiver = vm.envAddress("AAVE_QUOTE_PUSH_RECEIVER_MAINNET");
address quoteToken = vm.envOr("QUOTE_PUSH_SURPLUS_TOKEN_MAINNET", DEFAULT_USDC_MAINNET);
address deployer = vm.addr(pk);
address owner = vm.envOr("QUOTE_PUSH_TREASURY_OWNER", deployer);
address operator = vm.envOr("QUOTE_PUSH_TREASURY_OPERATOR", owner);
address gasRecipient = vm.envOr("QUOTE_PUSH_TREASURY_GAS_RECIPIENT", owner);
address recycleRecipient = vm.envOr("QUOTE_PUSH_TREASURY_RECYCLE_RECIPIENT", owner);
uint256 receiverReserve = vm.envOr("QUOTE_PUSH_RECEIVER_RESERVE_RAW", uint256(0));
uint256 managerReserve = vm.envOr("QUOTE_PUSH_TREASURY_RESERVE_RAW", uint256(0));
bool takeReceiverOwnership = vm.envOr("QUOTE_PUSH_TREASURY_TAKE_RECEIVER_OWNERSHIP", uint256(0)) == 1;
console.log("Deployer:", deployer);
console.log("Receiver:", receiver);
console.log("Quote token:", quoteToken);
console.log("Manager owner:", owner);
console.log("Manager operator:", operator);
console.log("Gas recipient:", gasRecipient);
console.log("Recycle recipient:", recycleRecipient);
console.log("Receiver reserve:", receiverReserve);
console.log("Manager reserve:", managerReserve);
console.log("Take receiver ownership:", takeReceiverOwnership);
vm.startBroadcast(pk);
QuotePushTreasuryManager manager = new QuotePushTreasuryManager(
owner,
receiver,
quoteToken,
operator,
gasRecipient,
recycleRecipient,
receiverReserve,
managerReserve
);
if (takeReceiverOwnership) {
AaveQuotePushFlashReceiver(receiver).transferOwnership(address(manager));
console.log("Receiver ownership transferred to manager");
}
vm.stopBroadcast();
console.log("QuotePushTreasuryManager:", address(manager));
}
}

50
script/flash/ManageQuotePushTreasuryManager.s.sol Normal file
View File

@@ -0,0 +1,50 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {QuotePushTreasuryManager} from "../../contracts/flash/QuotePushTreasuryManager.sol";
/**
* @title ManageQuotePushTreasuryManager
* @notice Harvest receiver surplus into the treasury manager and/or distribute
* quote to the configured gas and recycle recipients.
*
* Env:
* PRIVATE_KEY required
* QUOTE_PUSH_TREASURY_MANAGER_MAINNET required
* QUOTE_PUSH_TREASURY_HARVEST optional; default 1
* QUOTE_PUSH_TREASURY_GAS_DISTRIBUTION_RAW optional; default 0
* QUOTE_PUSH_TREASURY_RECYCLE_DISTRIBUTION_RAW optional; default 0
*/
contract ManageQuotePushTreasuryManager is Script {
function run() external {
uint256 pk = vm.envUint("PRIVATE_KEY");
address managerAddr = vm.envAddress("QUOTE_PUSH_TREASURY_MANAGER_MAINNET");
bool harvest = vm.envOr("QUOTE_PUSH_TREASURY_HARVEST", uint256(1)) == 1;
uint256 gasAmount = vm.envOr("QUOTE_PUSH_TREASURY_GAS_DISTRIBUTION_RAW", uint256(0));
uint256 recycleAmount = vm.envOr("QUOTE_PUSH_TREASURY_RECYCLE_DISTRIBUTION_RAW", uint256(0));
QuotePushTreasuryManager manager = QuotePushTreasuryManager(managerAddr);
console.log("manager", managerAddr);
console.log("harvest", harvest);
console.log("gasAmount", gasAmount);
console.log("recycleAmount", recycleAmount);
console.log("quoteBalanceBefore", manager.quoteBalance());
console.log("availableBefore", manager.availableQuote());
console.log("receiverSweepableBefore", manager.receiverSweepableQuote());
vm.startBroadcast(pk);
if (harvest) {
uint256 harvested = manager.harvestReceiverSurplus();
console.log("harvested", harvested);
}
if (gasAmount > 0 || recycleAmount > 0) {
manager.distributeToConfiguredRecipients(gasAmount, recycleAmount);
}
vm.stopBroadcast();
console.log("quoteBalanceAfter", manager.quoteBalance());
console.log("availableAfter", manager.availableQuote());
}
}

173
script/flash/RunManagedMainnetAaveCwusdcUsdcQuotePushCycle.s.sol Normal file
View File

@@ -0,0 +1,173 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {AaveQuotePushFlashReceiver} from "../../contracts/flash/AaveQuotePushFlashReceiver.sol";
import {QuotePushTreasuryManager} from "../../contracts/flash/QuotePushTreasuryManager.sol";
interface IDODOPMMPoolQuoteManaged {
function querySellQuote(address trader, uint256 payQuoteAmount) external view returns (uint256 receiveBaseAmount, uint256 mtFee);
}
/**
* @title RunManagedMainnetAaveCwusdcUsdcQuotePushCycle
* @notice Simulate or broadcast a full manager-backed cycle:
* flash quote-push -> harvest retained quote into treasury manager -> split to configured recipients.
*
* Env:
* Same flash envs as RunMainnetAaveCwusdcUsdcQuotePushOnce
* QUOTE_PUSH_TREASURY_MANAGER_MAINNET required
* QUOTE_PUSH_TREASURY_HARVEST optional; default 1
* QUOTE_PUSH_TREASURY_GAS_HOLDBACK_TARGET_RAW optional; default 0
*
* Notes:
* - Gas holdback target is a quote-denominated cap. The script computes:
* gasAmount = min(manager.availableQuote(), gasHoldbackTargetRaw)
* recycleAmount = manager.availableQuote() - gasAmount
* - This is primarily used by the keeper dry-run so flash and recycle happen in the
* same simulated environment and post-flash surplus is visible to the manager.
*/
contract RunManagedMainnetAaveCwusdcUsdcQuotePushCycle is Script {
address internal constant DEFAULT_POOL = 0x69776fc607e9edA8042e320e7e43f54d06c68f0E;
address internal constant DEFAULT_CWUSDC = 0x2de5F116bFcE3d0f922d9C8351e0c5Fc24b9284a;
address internal constant DEFAULT_USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function run() external {
uint256 pk = vm.envUint("PRIVATE_KEY");
address receiver = vm.envAddress("AAVE_QUOTE_PUSH_RECEIVER_MAINNET");
address managerAddr = vm.envAddress("QUOTE_PUSH_TREASURY_MANAGER_MAINNET");
address pool = vm.envOr("POOL_CWUSDC_USDC_MAINNET", DEFAULT_POOL);
address integration = vm.envAddress("DODO_PMM_INTEGRATION_MAINNET");
address baseToken = vm.envOr("CWUSDC_MAINNET", DEFAULT_CWUSDC);
address usdc = vm.envOr("USDC_MAINNET", DEFAULT_USDC);
address unwinder = vm.envAddress("QUOTE_PUSH_EXTERNAL_UNWINDER_MAINNET");
uint256 amount = vm.envUint("FLASH_QUOTE_AMOUNT_RAW");
bool harvest = vm.envOr("QUOTE_PUSH_TREASURY_HARVEST", uint256(1)) == 1;
uint256 gasHoldbackTargetRaw = vm.envOr("QUOTE_PUSH_TREASURY_GAS_HOLDBACK_TARGET_RAW", uint256(0));
QuotePushTreasuryManager manager = QuotePushTreasuryManager(managerAddr);
AaveQuotePushFlashReceiver.QuotePushParams memory p =
_loadQuotePushParams(receiver, pool, integration, baseToken, unwinder, amount);
console.log("receiver", receiver);
console.log("manager", managerAddr);
console.log("pool", pool);
console.log("amount", amount);
console.log("managerAvailableBefore", manager.availableQuote());
console.log("receiverSweepableBefore", manager.receiverSweepableQuote());
console.log("gasHoldbackTargetRaw", gasHoldbackTargetRaw);
vm.startBroadcast(pk);
AaveQuotePushFlashReceiver(receiver).flashQuotePush(usdc, amount, p);
uint256 harvested = 0;
if (harvest) {
uint256 receiverSweepableAfterFlash = manager.receiverSweepableQuote();
if (receiverSweepableAfterFlash > 0) {
harvested = manager.harvestReceiverSurplus();
}
console.log("receiverSweepableAfterFlash", receiverSweepableAfterFlash);
}
uint256 available = manager.availableQuote();
uint256 gasAmount = _min(available, gasHoldbackTargetRaw);
uint256 recycleAmount = available - gasAmount;
if (gasAmount > 0 || recycleAmount > 0) {
manager.distributeToConfiguredRecipients(gasAmount, recycleAmount);
}
vm.stopBroadcast();
console.log("harvested", harvested);
console.log("gasDistributionRaw", gasAmount);
console.log("recycleDistributionRaw", recycleAmount);
console.log("managerQuoteAfter", manager.quoteBalance());
console.log("managerAvailableAfter", manager.availableQuote());
console.log("receiverSweepableAfter", manager.receiverSweepableQuote());
}
function _loadQuotePushParams(
address receiver,
address pool,
address integration,
address baseToken,
address unwinder,
uint256 amount
) internal view returns (AaveQuotePushFlashReceiver.QuotePushParams memory p) {
uint256 minPmmNum = vm.envOr("MIN_OUT_PMM_NUM", uint256(985));
uint256 minPmmDen = vm.envOr("MIN_OUT_PMM_DEN", uint256(1000));
uint256 minOutPmm = vm.envOr("MIN_OUT_PMM", uint256(0));
if (minOutPmm == 0) {
(uint256 baseOut,) = IDODOPMMPoolQuoteManaged(pool).querySellQuote(receiver, amount);
minOutPmm = (baseOut * minPmmNum) / minPmmDen;
}
uint256 premiumBps = vm.envOr("AAVE_FLASH_PREMIUM_BPS", uint256(5));
uint256 buf = vm.envOr("MIN_OUT_UNWIND_BUFFER_RAW", uint256(5000));
uint256 minOutUnwind = vm.envOr("MIN_OUT_UNWIND", uint256(0));
if (minOutUnwind == 0) {
uint256 premium = (amount * premiumBps) / 10000;
minOutUnwind = amount + premium + buf;
}
uint256 unwindMode = vm.envOr("UNWIND_MODE", uint256(0));
bytes memory unwindData;
if (unwindMode == 0) {
uint24 fee = uint24(vm.envUint("UNWIND_V3_FEE_U24"));
unwindData = abi.encode(fee);
} else if (unwindMode == 1) {
address dodoPool = vm.envAddress("UNWIND_DODO_POOL");
unwindData = abi.encode(dodoPool);
} else if (unwindMode == 2) {
string memory pathHex = vm.envString("UNWIND_V3_PATH_HEX");
bytes memory path = vm.parseBytes(pathHex);
unwindData = abi.encode(path);
} else if (unwindMode == 4) {
address poolA = vm.envAddress("UNWIND_TWO_HOP_POOL_A");
address poolB = vm.envAddress("UNWIND_TWO_HOP_POOL_B");
address midToken = vm.envAddress("UNWIND_TWO_HOP_MID_TOKEN");
uint256 minMidOut = vm.envOr("UNWIND_MIN_MID_OUT_RAW", uint256(1));
unwindData = abi.encode(poolA, poolB, midToken, minMidOut);
} else if (unwindMode == 5) {
address dodoPool = vm.envAddress("UNWIND_DODO_POOL");
address intermediateToken = vm.envAddress("UNWIND_INTERMEDIATE_TOKEN");
uint256 minIntermediateOut = vm.envOr("UNWIND_MIN_INTERMEDIATE_OUT_RAW", uint256(1));
string memory pathHex = vm.envString("UNWIND_V3_PATH_HEX");
bytes memory path = vm.parseBytes(pathHex);
unwindData = abi.encode(dodoPool, intermediateToken, minIntermediateOut, path);
} else {
revert("UNWIND_MODE must be 0, 1, 2, 4, or 5");
}
p = AaveQuotePushFlashReceiver.QuotePushParams({
integration: integration,
pmmPool: pool,
baseToken: baseToken,
externalUnwinder: unwinder,
minOutPmm: minOutPmm,
minOutUnwind: minOutUnwind,
unwindData: unwindData,
atomicBridge: AaveQuotePushFlashReceiver.AtomicBridgeParams({
coordinator: address(0),
sourceChain: 0,
destinationChain: 0,
destinationAsset: address(0),
bridgeAmount: 0,
minDestinationAmount: 0,
destinationRecipient: address(0),
destinationDeadline: 0,
routeId: bytes32(0),
settlementMode: bytes32(0),
submitCommitment: false
})
});
console.log("minOutPmm", minOutPmm);
console.log("minOutUnwind", minOutUnwind);
}
function _min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
}

47
script/flash/SweepAaveQuotePushFlashReceiverSurplus.s.sol Normal file
View File

@@ -0,0 +1,47 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {AaveQuotePushFlashReceiver} from "../../contracts/flash/AaveQuotePushFlashReceiver.sol";
/**
* @title SweepAaveQuotePushFlashReceiverSurplus
* @notice Owner-operated surplus recovery for a deployed AaveQuotePushFlashReceiver.
*
* Env:
* PRIVATE_KEY required (must be receiver owner)
* AAVE_QUOTE_PUSH_RECEIVER_MAINNET required
* QUOTE_PUSH_SURPLUS_TOKEN_MAINNET optional; defaults to USDC mainnet
* QUOTE_PUSH_SURPLUS_RECIPIENT optional; defaults to deployer derived from PRIVATE_KEY
* QUOTE_PUSH_SURPLUS_RESERVE_RAW optional; keep this much on receiver when sweeping surplus mode
* QUOTE_PUSH_SURPLUS_EXACT_AMOUNT_RAW optional; if > 0, sweep this exact amount via sweepToken()
*/
contract SweepAaveQuotePushFlashReceiverSurplus is Script {
address internal constant DEFAULT_USDC_MAINNET = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
function run() external {
uint256 pk = vm.envUint("PRIVATE_KEY");
address receiver = vm.envAddress("AAVE_QUOTE_PUSH_RECEIVER_MAINNET");
address token = vm.envOr("QUOTE_PUSH_SURPLUS_TOKEN_MAINNET", DEFAULT_USDC_MAINNET);
address deployer = vm.addr(pk);
address recipient = vm.envOr("QUOTE_PUSH_SURPLUS_RECIPIENT", deployer);
uint256 reserveRetained = vm.envOr("QUOTE_PUSH_SURPLUS_RESERVE_RAW", uint256(0));
uint256 exactAmount = vm.envOr("QUOTE_PUSH_SURPLUS_EXACT_AMOUNT_RAW", uint256(0));
console.log("receiver", receiver);
console.log("token", token);
console.log("recipient", recipient);
console.log("reserveRetained", reserveRetained);
console.log("exactAmount", exactAmount);
vm.startBroadcast(pk);
if (exactAmount > 0) {
AaveQuotePushFlashReceiver(receiver).sweepToken(token, recipient, exactAmount);
console.log("sweptExact", exactAmount);
} else {
uint256 swept = AaveQuotePushFlashReceiver(receiver).sweepQuoteSurplus(token, recipient, reserveRetained);
console.log("sweptSurplus", swept);
}
vm.stopBroadcast();
}
}

17
script/tokenization/DeployTokenRegistry.s.sol Normal file
View File

@@ -0,0 +1,17 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {TokenRegistry} from "../../contracts/tokenization/TokenRegistry.sol";
contract DeployTokenRegistry is Script {
function run() external returns (address registry) {
address admin = vm.envAddress("ADMIN_ADDRESS");
vm.startBroadcast();
registry = address(new TokenRegistry(admin));
vm.stopBroadcast();
console.log("TokenRegistry deployed at:", registry);
}
}

17
script/tokenization/DeployTokenizedEUR.s.sol Normal file
View File

@@ -0,0 +1,17 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {TokenizedEUR} from "../../contracts/tokenization/TokenizedEUR.sol";
contract DeployTokenizedEUR is Script {
function run() external returns (address tokenizedEUR) {
address admin = vm.envAddress("ADMIN_ADDRESS");
vm.startBroadcast();
tokenizedEUR = address(new TokenizedEUR(admin));
vm.stopBroadcast();
console.log("TokenizedEUR deployed at:", tokenizedEUR);
}
}

30
script/tokenization/RegisterToken.s.sol Normal file
View File

@@ -0,0 +1,30 @@
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import {Script, console} from "forge-std/Script.sol";
import {TokenRegistry} from "../../contracts/tokenization/TokenRegistry.sol";
contract RegisterToken is Script {
function run(
address registryAddress,
address tokenAddress,
string memory tokenId,
string memory underlyingAsset,
address issuer,
string memory backingReserve
) external {
TokenRegistry registry = TokenRegistry(registryAddress);
vm.startBroadcast();
registry.registerToken(
tokenAddress,
tokenId,
underlyingAsset,
issuer,
backingReserve
);
vm.stopBroadcast();
console.log("Token registered:", tokenId);
}
}