Implement simple bridge algo (#17)

kevincheng96 · web-flow · commit 65e49d3869ec · 2024-06-17T11:20:24.000-07:00
This implements a basic algo for figuring the amount to bridge from each
chain. It loops through account balances on each chain and greedily
attempts to bridge until the total amount needed is reached.
diff --git a/.github/workflows/gas-snapshot.yml b/.github/workflows/gas-snapshot.yml
@@ -5,7 +5,7 @@ on:
   pull_request:
 
 env:
-  FOUNDRY_PROFILE: ci
+  FOUNDRY_PROFILE: ir
 
 jobs:
   snapshot-gas:
@@ -29,7 +29,7 @@ jobs:
         run: |
           set -euo pipefail
           # grep -E '^test'  -- skip over test results, just get diffs
-          FOUNDRY_PROFILE=ir forge snapshot --diff \
+          forge snapshot --diff \
             | grep -E '^test'   \
             | tee .gas-snapshot.new
         env:
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
@@ -5,7 +5,7 @@ on:
   pull_request:
 
 env:
-  FOUNDRY_PROFILE: ci
+  FOUNDRY_PROFILE: ir
 
 jobs:
   check:
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
@@ -5,7 +5,7 @@ on:
   pull_request:
 
 env:
-  FOUNDRY_PROFILE: ci
+  FOUNDRY_PROFILE: ir
 
 jobs:
   check:
@@ -30,12 +30,12 @@ jobs:
       - name: Run Forge build
         run: |
           forge --version
-          FOUNDRY_PROFILE=ir forge build --sizes
+          forge build --sizes
         id: build
 
       - name: Run Forge tests
         run: |
-          FOUNDRY_PROFILE=ir forge test
+          forge test
         id: test
         env:
           NODE_PROVIDER_BYPASS_KEY: ${{ secrets.NODE_PROVIDER_BYPASS_KEY }}
diff --git a/.github/workflows/vendoza.yml b/.github/workflows/vendoza.yml
@@ -5,7 +5,7 @@ on:
   pull_request:
 
 env:
-  FOUNDRY_PROFILE: ci
+  FOUNDRY_PROFILE: ir
 
 jobs:
   check:
diff --git a/src/builder/Accounts.sol b/src/builder/Accounts.sol
@@ -88,4 +88,13 @@ library Accounts {
         }
         return totalBalance;
     }
+
+    function getBalanceOnChain(string memory assetSymbol, uint256 chainId, ChainAccounts[] memory chainAccountsList)
+        internal
+        pure
+        returns (uint256)
+    {
+        AssetPositions memory positions = findAssetPositions(assetSymbol, chainId, chainAccountsList);
+        return sumBalances(positions);
+    }
 }
diff --git a/src/builder/Actions.sol b/src/builder/Actions.sol
@@ -24,6 +24,7 @@ library Actions {
 
     /* ===== Custom Errors ===== */
 
+    error BridgingUnsupportedForAsset();
     error InvalidAssetForBridge();
 
     /* ===== Input Types ===== */
@@ -38,11 +39,11 @@ library Actions {
         uint256 blockTimestamp;
     }
 
-    struct BridgeUSDC {
+    struct BridgeAsset {
         Accounts.ChainAccounts[] chainAccountsList;
         string assetSymbol;
         uint256 amount;
-        uint256 originChainId;
+        uint256 srcChainId;
         address sender;
         uint256 destinationChainId;
         address recipient;
@@ -83,37 +84,70 @@ library Actions {
         uint256 destinationChainId;
     }
 
-    function bridgeUSDC(BridgeUSDC memory bridge)
+    function bridgeAsset(BridgeAsset memory bridge)
         internal
         pure
-        returns (IQuarkWallet.QuarkOperation memory /*, QuarkAction memory*/ )
+        returns (IQuarkWallet.QuarkOperation memory, Action memory)
+    {
+        if (Strings.stringEqIgnoreCase(bridge.assetSymbol, "USDC")) {
+            return bridgeUSDC(bridge);
+        } else {
+            revert BridgingUnsupportedForAsset();
+        }
+    }
+
+    function bridgeUSDC(BridgeAsset memory bridge)
+        internal
+        pure
+        returns (IQuarkWallet.QuarkOperation memory, Action memory)
     {
         if (!Strings.stringEqIgnoreCase(bridge.assetSymbol, "USDC")) {
             revert InvalidAssetForBridge();
         }
 
-        Accounts.ChainAccounts memory originChainAccounts =
-            Accounts.findChainAccounts(bridge.originChainId, bridge.chainAccountsList);
+        Accounts.ChainAccounts memory srcChainAccounts =
+            Accounts.findChainAccounts(bridge.srcChainId, bridge.chainAccountsList);
 
-        Accounts.AssetPositions memory originUSDCPositions =
-            Accounts.findAssetPositions("USDC", originChainAccounts.assetPositionsList);
+        Accounts.AssetPositions memory srcUSDCPositions =
+            Accounts.findAssetPositions("USDC", srcChainAccounts.assetPositionsList);
 
-        Accounts.QuarkState memory accountState =
-            Accounts.findQuarkState(bridge.sender, originChainAccounts.quarkStates);
+        Accounts.QuarkState memory accountState = Accounts.findQuarkState(bridge.sender, srcChainAccounts.quarkStates);
 
         bytes[] memory scriptSources = new bytes[](1);
         scriptSources[0] = CCTP.bridgeScriptSource();
 
-        // CCTP bridge
-        return IQuarkWallet.QuarkOperation({
+        // Construct QuarkOperation
+        IQuarkWallet.QuarkOperation memory quarkOperation = IQuarkWallet.QuarkOperation({
             nonce: accountState.quarkNextNonce,
-            scriptAddress: CodeJarHelper.getCodeAddress(bridge.originChainId, scriptSources[0]),
+            scriptAddress: CodeJarHelper.getCodeAddress(scriptSources[0]),
             scriptCalldata: CCTP.encodeBridgeUSDC(
-                bridge.originChainId, bridge.destinationChainId, bridge.amount, bridge.recipient, originUSDCPositions.asset
+                bridge.srcChainId, bridge.destinationChainId, bridge.amount, bridge.recipient, srcUSDCPositions.asset
                 ),
             scriptSources: scriptSources,
             expiry: bridge.blockTimestamp + BRIDGE_EXPIRY_BUFFER
         });
+
+        // Construct Action
+        BridgeActionContext memory bridgeActionContext = BridgeActionContext({
+            amount: bridge.amount,
+            price: srcUSDCPositions.usdPrice,
+            token: srcUSDCPositions.asset,
+            chainId: bridge.srcChainId,
+            recipient: bridge.recipient,
+            destinationChainId: bridge.destinationChainId
+        });
+        Action memory action = Actions.Action({
+            chainId: bridge.srcChainId,
+            quarkAccount: bridge.sender,
+            actionType: ACTION_TYPE_BRIDGE,
+            actionContext: abi.encode(bridgeActionContext),
+            paymentMethod: PAYMENT_METHOD_OFFCHAIN,
+            // Null address for OFFCHAIN payment.
+            paymentToken: address(0),
+            paymentMaxCost: 0
+        });
+
+        return (quarkOperation, action);
     }
 
     // TODO: Handle paycall
@@ -149,7 +183,7 @@ library Actions {
         // Construct QuarkOperation
         IQuarkWallet.QuarkOperation memory quarkOperation = IQuarkWallet.QuarkOperation({
             nonce: accountState.quarkNextNonce,
-            scriptAddress: CodeJarHelper.getCodeAddress(transfer.chainId, type(TransferActions).creationCode),
+            scriptAddress: CodeJarHelper.getCodeAddress(type(TransferActions).creationCode),
             scriptCalldata: scriptCalldata,
             scriptSources: scriptSources,
             expiry: transfer.blockTimestamp + TRANSFER_EXPIRY_BUFFER
diff --git a/src/builder/BridgeRoutes.sol b/src/builder/BridgeRoutes.sol
@@ -74,17 +74,17 @@ library CCTP {
     }
 
     function encodeBridgeUSDC(
-        uint256 originChainId,
-        uint256 destChainId,
+        uint256 srcChainId,
+        uint256 dstChainId,
         uint256 amount,
         address recipient,
         address usdcAddress
     ) internal pure returns (bytes memory) {
         return abi.encodeWithSelector(
             CCTPBridgeActions.bridgeUSDC.selector,
-            knownBridge(originChainId),
+            knownBridge(srcChainId),
             amount,
-            knownDomainId(destChainId),
+            knownDomainId(dstChainId),
             bytes32(uint256(uint160(recipient))),
             usdcAddress
         );
diff --git a/src/builder/CodeJarHelper.sol b/src/builder/CodeJarHelper.sol
@@ -7,7 +7,7 @@ library CodeJarHelper {
     /// @notice The address for CodeJar on all chains
     address constant CODE_JAR_ADDRESS = 0x2b68764bCfE9fCD8d5a30a281F141f69b69Ae3C8;
 
-    function getCodeAddress(uint256 chainId, bytes memory code) public pure returns (address) {
+    function getCodeAddress(bytes memory code) public pure returns (address) {
         return address(
             uint160(uint256(keccak256(abi.encodePacked(bytes1(0xff), CODE_JAR_ADDRESS, uint256(0), keccak256(code)))))
         );
diff --git a/src/builder/QuarkBuilder.sol b/src/builder/QuarkBuilder.sol
@@ -13,6 +13,7 @@ contract QuarkBuilder {
     /* ===== Constants ===== */
 
     string constant VERSION = "1.0.0";
+    uint256 constant MAX_BRIDGE_ACTION = 1;
 
     /* ===== Custom Errors ===== */
 
@@ -21,6 +22,7 @@ contract QuarkBuilder {
     error InsufficientFunds();
     error InvalidInput();
     error MaxCostTooHigh();
+    error TooManyBridgeOperations();
 
     /* ===== Input Types ===== */
 
@@ -93,42 +95,75 @@ contract QuarkBuilder {
             new IQuarkWallet.QuarkOperation[](chainAccountsList.length);
 
         if (needsBridgedFunds(transferIntent, chainAccountsList)) {
-            // TODO: actually enumerate chain accounts other than the destination chain,
-            // and check balances and choose amounts to send and from which.
-            //
-            // for now: simplify!
-            // only check 8453 (Base mainnet);
-            //   check every account;
-            //     sum the balances and if there's enough to cover the gap,
-            //     bridge from each account in arbitrary order of appearance
-            //     until there is enough.
-            if (payment.isToken) {
-                // wrap around paycall
-                // TODO: need to embed price feed addresses for known tokens before we can do paycall.
-                // ^^^ look up USDC price feeds for each supported chain?
-                // we only need USDC/USD and only on chains 1 (mainnet) and 8453 (base mainnet).
-            } else {
-                quarkOperations[actionIndex++] = Actions.bridgeUSDC(
-                    Actions.BridgeUSDC({
-                        chainAccountsList: chainAccountsList,
-                        assetSymbol: transferIntent.assetSymbol,
-                        amount: transferIntent.amount,
-                        // where it comes from
-                        originChainId: 8453, // FIXME: originChainId
-                        sender: address(0), // FIXME: sender
-                        // where it goes
-                        destinationChainId: transferIntent.chainId,
-                        recipient: transferIntent.recipient,
-                        blockTimestamp: transferIntent.blockTimestamp
-                    })
-                );
-                // TODO: also append a Actions.Action to the actions array.
-                // See: BridgeUSDC TODO for returning a Actions.Action.
+            // Note: Assumes that the asset uses the same # of decimals on each chain
+            uint256 balanceOnDstChain =
+                Accounts.getBalanceOnChain(transferIntent.assetSymbol, transferIntent.chainId, chainAccountsList);
+            uint256 amountLeftToBridge = transferIntent.amount - balanceOnDstChain;
+
+            uint256 bridgeActionCount = 0;
+            // TODO: bridge routing logic (which bridge to prioritize, how many bridges?)
+            // Iterate chainAccountList and find upto 2 chains that can provide enough fund
+            // Backend can provide optimal routes by adjust the order in chainAccountList.
+            for (uint256 i = 0; i < chainAccountsList.length; ++i) {
+                if (amountLeftToBridge == 0) {
+                    break;
+                }
+
+                Accounts.ChainAccounts memory srcChainAccounts = chainAccountsList[i];
+                if (srcChainAccounts.chainId == transferIntent.chainId) {
+                    continue;
+                }
+
+                if (
+                    !BridgeRoutes.canBridge(srcChainAccounts.chainId, transferIntent.chainId, transferIntent.assetSymbol)
+                ) {
+                    continue;
+                }
+
+                Accounts.AssetPositions memory srcAssetPositions =
+                    Accounts.findAssetPositions(transferIntent.assetSymbol, srcChainAccounts.assetPositionsList);
+                Accounts.AccountBalance[] memory srcAccountBalances = srcAssetPositions.accountBalances;
+                // TODO: Make logic smarter. Currently, this uses a greedy algorithm.
+                // e.g. Optimize by trying to bridge with the least amount of bridge operations
+                for (uint256 j = 0; j < srcAccountBalances.length; ++j) {
+                    if (bridgeActionCount >= MAX_BRIDGE_ACTION) {
+                        revert TooManyBridgeOperations();
+                    }
+
+                    uint256 amountToBridge = srcAccountBalances[j].balance >= amountLeftToBridge
+                        ? amountLeftToBridge
+                        : srcAccountBalances[j].balance;
+                    amountLeftToBridge -= amountToBridge;
+
+                    if (payment.isToken) {
+                        // TODO: wrap around paycall
+                    } else {
+                        (quarkOperations[actionIndex], actions[actionIndex]) = Actions.bridgeAsset(
+                            Actions.BridgeAsset({
+                                chainAccountsList: chainAccountsList,
+                                assetSymbol: transferIntent.assetSymbol,
+                                amount: amountToBridge,
+                                // where it comes from
+                                srcChainId: srcChainAccounts.chainId,
+                                sender: srcAccountBalances[j].account,
+                                // where it goes
+                                destinationChainId: transferIntent.chainId,
+                                recipient: transferIntent.sender,
+                                blockTimestamp: transferIntent.blockTimestamp
+                            })
+                        );
+                        actionIndex++;
+                        bridgeActionCount++;
+                    }
+                }
+            }
+
+            if (amountLeftToBridge > 0) {
+                revert FundsUnavailable();
             }
         }
 
         // Then, transferIntent `amount` of `assetSymbol` to `recipient`
-        // TODO: construct action contexts
         if (payment.isToken) {
             // wrap around paycall
         } else {
@@ -221,9 +256,8 @@ contract QuarkBuilder {
         pure
         returns (bool)
     {
-        Accounts.AssetPositions memory localPositions =
-            Accounts.findAssetPositions(transferIntent.assetSymbol, transferIntent.chainId, chainAccountsList);
-        return Accounts.sumBalances(localPositions) < transferIntent.amount;
+        return Accounts.getBalanceOnChain(transferIntent.assetSymbol, transferIntent.chainId, chainAccountsList)
+            < transferIntent.amount;
     }
 
     // Assert that each chain has sufficient funds to cover the max cost for that chain.
diff --git a/test/QuarkBuilder.t.sol b/test/QuarkBuilder.t.sol

Original file line number	Diff line number	Diff line change
`@@ -88,4 +88,13 @@ library Accounts {`
`88`	`88`	`}`
`89`	`89`	`return totalBalance;`
`90`	`90`	`}`
	`91`	`+`
	`92`	`+ function getBalanceOnChain(string memory assetSymbol, uint256 chainId, ChainAccounts[] memory chainAccountsList)`
	`93`	`+ internal`
	`94`	`+ pure`
	`95`	`+ returns (uint256)`
	`96`	`+ {`
	`97`	`+ AssetPositions memory positions = findAssetPositions(assetSymbol, chainId, chainAccountsList);`
	`98`	`+ return sumBalances(positions);`
	`99`	`+ }`
`91`	`100`	`}`