feat: Solana rebalancing and CCTP finalization

package.json

@@ -15,7 +15,7 @@
     "@across-protocol/sdk": "4.2.5",
     "@arbitrum/sdk": "^4.0.2",
     "@consensys/linea-sdk": "^0.2.1",
-    "@coral-xyz/borsh": "^0.30.1",
+    "@coral-xyz/anchor": "^0.31.1",
     "@defi-wonderland/smock": "^2.3.5",
     "@eth-optimism/sdk": "^3.3.2",
     "@ethersproject/abi": "^5.7.0",
@@ -27,7 +27,7 @@
     "@maticnetwork/maticjs": "^3.6.0",
     "@maticnetwork/maticjs-ethers": "^1.0.3",
     "@openzeppelin/hardhat-upgrades": "^1.28.0",
-    "@solana/web3.js": "2.0.0",
+    "@solana-program/token": "^0.5.0",
     "@uma/common": "2.33.0",
     "@uma/logger": "^1.3.0",
     "axios": "^1.7.4",

src/adapter/bridges/SolanaUsdcCCTPBridge.ts

@@ -0,0 +1,181 @@
+import { Contract, Signer } from "ethers";
+import { BridgeTransactionDetails, BaseBridgeAdapter, BridgeEvents } from "./BaseBridgeAdapter";
+import {
+  BigNumber,
+  EventSearchConfig,
+  TOKEN_SYMBOLS_MAP,
+  compareAddressesSimple,
+  assert,
+  toBN,
+  getCctpDomainForChainId,
+  Address,
+  EvmAddress,
+  SvmAddress,
+  paginatedEventQuery,
+  ZERO_BYTES,
+  SVMProvider,
+  isDefined,
+  getSvmSignerFromEvmSigner,
+  Wallet,
+  getAssociatedTokenAddress,
+} from "../../utils";
+import { processEvent } from "../utils";
+import { getCctpTokenMessenger, isCctpV2L2ChainId } from "../../utils/CCTPUtils";
+import { CCTP_NO_DOMAIN } from "@across-protocol/constants";
+import { arch } from "@across-protocol/sdk";
+import { TokenMessengerMinterIdl } from "@across-protocol/contracts";
+
+type MintAndWithdrawData = {
+  mintRecipient: string;
+  amount: bigint;
+};
+
+export class SolanaUsdcCCTPBridge extends BaseBridgeAdapter {
+  private CCTP_MAX_SEND_AMOUNT = toBN(1_000_000_000_000); // 1MM USDC.
+  private IS_CCTP_V2 = false;
+  private readonly l1UsdcTokenAddress: EvmAddress;
+  private readonly l2UsdcTokenAddress: SvmAddress;
+  private readonly solanaMessageTransmitter: SvmAddress;
+  // We need the constructor to operate in a synchronous context, but the call to construct an event client is asynchronous, so
+  // this bridge holds onto the client promise and lazily evaluates it for when it needs to use it (in `queryL2BridgeFinalizationEvents`).
+  private readonly solanaEventsClientPromise: Promise<arch.svm.SvmCpiEventsClient>;
+  private solanaEventsClient: arch.svm.SvmCpiEventsClient;
+  private svmAddress: string;
+
+  constructor(l2chainId: number, hubChainId: number, l1Signer: Signer, l2Provider: SVMProvider) {
+    super(l2chainId, hubChainId, l1Signer, [EvmAddress.from(getCctpTokenMessenger(l2chainId, hubChainId).address)]);
+    assert(
+      getCctpDomainForChainId(l2chainId) !== CCTP_NO_DOMAIN && getCctpDomainForChainId(hubChainId) !== CCTP_NO_DOMAIN,
+      "Unknown CCTP domain ID"
+    );
+    this.IS_CCTP_V2 = isCctpV2L2ChainId(l2chainId);
+
+    const { address: l1Address, abi: l1Abi } = getCctpTokenMessenger(l2chainId, hubChainId);
+    this.l1Bridge = new Contract(l1Address, l1Abi, l1Signer);
+
+    const { address: l2Address } = getCctpTokenMessenger(l2chainId, l2chainId);
+    this.solanaMessageTransmitter = SvmAddress.from(l2Address);
+    this.solanaEventsClientPromise = arch.svm.SvmCpiEventsClient.createFor(
+      l2Provider,
+      l2Address,
+      TokenMessengerMinterIdl
+    );
+    this.l1UsdcTokenAddress = EvmAddress.from(TOKEN_SYMBOLS_MAP.USDC.addresses[this.hubChainId]);
+    this.l2UsdcTokenAddress = SvmAddress.from(TOKEN_SYMBOLS_MAP.USDC.addresses[this.l2chainId]);
+  }
+
+  private get l2DestinationDomain(): number {
+    return getCctpDomainForChainId(this.l2chainId);
+  }
+
+  protected resolveL2TokenAddress(l1Token: EvmAddress): string {
+    l1Token;
+    return TOKEN_SYMBOLS_MAP.USDC.addresses[this.l2chainId];
+  }
+
+  async constructL1ToL2Txn(
+    toAddress: Address,
+    l1Token: EvmAddress,
+    _l2Token: Address,
+    amount: BigNumber
+  ): Promise<BridgeTransactionDetails> {
+    assert(compareAddressesSimple(l1Token.toAddress(), TOKEN_SYMBOLS_MAP.USDC.addresses[this.hubChainId]));
+    const signer = await this.l1Signer.getAddress();
+    assert(compareAddressesSimple(signer, toAddress.toEvmAddress()), "Cannot rebalance to a non-signer address");
+    const associatedTokenAddress = await this._getAssociatedTokenAddress();
+    amount = amount.gt(this.CCTP_MAX_SEND_AMOUNT) ? this.CCTP_MAX_SEND_AMOUNT : amount;
+    return Promise.resolve({
+      contract: this.getL1Bridge(),
+      method: "depositForBurn",
+      args: this.IS_CCTP_V2
+        ? [
+            amount,
+            this.l2DestinationDomain,
+            associatedTokenAddress.toBytes32(),
+            this.l1UsdcTokenAddress.toAddress(),
+            ZERO_BYTES, // Anyone can finalize the message on domain when this is set to bytes32(0)
+            0, // maxFee set to 0 so this will be a "standard" speed transfer
+            2000, // Hardcoded minFinalityThreshold value for standard transfer
+          ]
+        : [amount, this.l2DestinationDomain, associatedTokenAddress.toBytes32(), this.l1UsdcTokenAddress.toAddress()],
+    });
+  }
+
+  async queryL1BridgeInitiationEvents(
+    l1Token: EvmAddress,
+    fromAddress: EvmAddress,
+    toAddress: Address,
+    eventConfig: EventSearchConfig
+  ): Promise<BridgeEvents> {
+    const signer = await this.l1Signer.getAddress();
+    // @todo. We can only track EOA transfers of the signer of the bot since we cannot translate an EVM address to an SVM token account
+    // unless we have knowledge of the private key.
+    if (fromAddress.toAddress() !== signer) {
+      return {};
+    }
+    const associatedTokenAddress = await this._getAssociatedTokenAddress();
+    assert(compareAddressesSimple(l1Token.toAddress(), TOKEN_SYMBOLS_MAP.USDC.addresses[this.hubChainId]));
+    const eventFilterArgs = this.IS_CCTP_V2
+      ? [this.l1UsdcTokenAddress.toAddress(), undefined, fromAddress.toAddress()]
+      : [undefined, this.l1UsdcTokenAddress.toAddress(), undefined, fromAddress.toAddress()];
+    const eventFilter = this.getL1Bridge().filters.DepositForBurn(...eventFilterArgs);
+    const events = (await paginatedEventQuery(this.getL1Bridge(), eventFilter, eventConfig)).filter((event) =>
+      compareAddressesSimple(event.args.mintRecipient, associatedTokenAddress.toBytes32())
+    );
+    return {
+      [this.resolveL2TokenAddress(l1Token)]: events.map((event) => processEvent(event, "amount")),
+    };
+  }
+
+  async queryL2BridgeFinalizationEvents(
+    l1Token: EvmAddress,
+    fromAddress: EvmAddress,
+    toAddress: Address,
+    eventConfig: EventSearchConfig
+  ): Promise<BridgeEvents> {
+    const signer = await this.l1Signer.getAddress();
+    // @todo. We can only track EOA transfers of the signer of the bot since we cannot translate an EVM address to an SVM token account
+    // unless we have knowledge of the private key.
+    if (fromAddress.toAddress() !== signer) {
+      return {};
+    }
+    const associatedTokenAddress = await this._getAssociatedTokenAddress();
+
+    // Lazily evaluate the events client.
+    this.solanaEventsClient ??= await this.solanaEventsClientPromise;
+    assert(compareAddressesSimple(l1Token.toAddress(), TOKEN_SYMBOLS_MAP.USDC.addresses[this.hubChainId]));
+    const l2FinalizationEvents = await this.solanaEventsClient.queryDerivedAddressEvents(
+      "MintAndWithdraw",
+      this.solanaMessageTransmitter.toV2Address(),
+      BigInt(eventConfig.from),
+      BigInt(eventConfig.to)
+    );
+    return {
+      [this.resolveL2TokenAddress(l1Token)]: l2FinalizationEvents
+        .map((event) => {
+          const data = event.data as MintAndWithdrawData;
+          if (String(data.mintRecipient) !== associatedTokenAddress.toBase58()) {
+            return undefined;
+          }
+          return {
+            amount: toBN(data.amount),
+            blockNumber: Number(event.slot),
+            txnRef: event.signature,
+            // There is no log/transaction index on Solana.
+            txnIndex: 0,
+            logIndex: 0,
+          };
+        })
+        .filter(isDefined),
+    };
+  }
+
+  async _getAssociatedTokenAddress(): Promise<Address> {
+    const svmSigner = getSvmSignerFromEvmSigner(this.l1Signer as Wallet);
+    const associatedTokenAddress = await getAssociatedTokenAddress(
+      SvmAddress.from(svmSigner.publicKey.toBase58()),
+      this.l2UsdcTokenAddress
+    );
+    return SvmAddress.from(associatedTokenAddress as string);
+  }
+}

src/adapter/bridges/index.ts

@@ -18,4 +18,5 @@ export * from "./UsdcCCTPBridge";
 export * from "./ZKStackBridge";
 export * from "./ZKStackUSDCBridge";
 export * from "./ZKStackWethBridge";
+export * from "./SolanaUsdcCCTPBridge";
 export * from "./OFTBridge";

src/clients/TokenClient.ts

@@ -4,7 +4,6 @@ import { CachingMechanismInterface, L1Token, Deposit } from "../interfaces";
 import {
   BigNumber,
   bnZero,
-  chainIsEvm,
   Contract,
   dedupArray,
   ERC20,
@@ -24,6 +23,7 @@ import {
   getTokenInfo,
   isEVMSpokePoolClient,
   assert,
+  isSVMSpokePoolClient,
 } from "../utils";
 
 export type TokenDataType = { [chainId: number]: { [token: string]: { balance: BigNumber; allowance: BigNumber } } };
@@ -223,41 +223,49 @@ export class TokenClient {
     chainId: number,
     hubPoolTokens: L1Token[]
   ): Promise<Record<string, { balance: BigNumber; allowance: BigNumber }>> {
-    if (!chainIsEvm(chainId)) {
-      return {}; // @todo
-    }
-
     const spokePoolClient = this.spokePoolClients[chainId];
 
-    assert(isEVMSpokePoolClient(spokePoolClient));
-    const multicall3 = sdkUtils.getMulticall3(chainId, spokePoolClient.spokePool.provider);
-    if (!isDefined(multicall3)) {
-      return this.fetchTokenData(chainId, hubPoolTokens);
-    }
+    if (isEVMSpokePoolClient(spokePoolClient)) {
+      const multicall3 = sdkUtils.getMulticall3(chainId, spokePoolClient.spokePool.provider);
+      if (!isDefined(multicall3)) {
+        return this.fetchTokenData(chainId, hubPoolTokens);
+      }
 
-    const { relayerAddress } = this;
-    const balances: sdkUtils.Call3[] = [];
-    const allowances: sdkUtils.Call3[] = [];
-    this.resolveRemoteTokens(chainId, hubPoolTokens).forEach((token) => {
-      balances.push({ contract: token, method: "balanceOf", args: [relayerAddress] });
-      allowances.push({
-        contract: token,
-        method: "allowance",
-        args: [relayerAddress, spokePoolClient.spokePoolAddress.toEvmAddress()],
+      const { relayerAddress } = this;
+      const balances: sdkUtils.Call3[] = [];
+      const allowances: sdkUtils.Call3[] = [];
+      this.resolveRemoteTokens(chainId, hubPoolTokens).forEach((token) => {
+        balances.push({ contract: token, method: "balanceOf", args: [relayerAddress] });
+        allowances.push({
+          contract: token,
+          method: "allowance",
+          args: [relayerAddress, spokePoolClient.spokePoolAddress.toEvmAddress()],
+        });
       });
-    });
 
-    const calls = [...balances, ...allowances];
-    const results = await sdkUtils.aggregate(multicall3, calls);
+      const calls = [...balances, ...allowances];
+      const results = await sdkUtils.aggregate(multicall3, calls);
 
-    const allowanceOffset = balances.length;
-    const balanceInfo = Object.fromEntries(
-      balances.map(({ contract: { address } }, idx) => {
-        return [address, { balance: results[idx][0], allowance: results[allowanceOffset + idx][0] }];
-      })
-    );
+      const allowanceOffset = balances.length;
+      const balanceInfo = Object.fromEntries(
+        balances.map(({ contract: { address } }, idx) => {
+          return [address, { balance: results[idx][0], allowance: results[allowanceOffset + idx][0] }];
+        })
+      );
 
-    return balanceInfo;
+      return balanceInfo;
+    } else if (isSVMSpokePoolClient(spokePoolClient)) {
+      return Object.fromEntries(
+        hubPoolTokens
+          .map((token) => {
+            const remoteToken = getRemoteTokenForL1Token(token.address, chainId, {
+              chainId: this.hubPoolClient.chainId,
+            });
+            return isDefined(remoteToken) ? [remoteToken, { balance: toBN(0), allowance: toBN(0) }] : undefined;
+          })
+          .filter(isDefined)
+      );
+    }
   }
 
   async update(): Promise<void> {

src/clients/bridges/AdapterManager.ts

@@ -25,6 +25,7 @@ import {
   getRemoteTokenForL1Token,
   getTokenInfo,
   isEVMSpokePoolClient,
+  isSVMSpokePoolClient,
 } from "../../utils";
 import { SpokePoolClient, HubPoolClient } from "../";
 import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "@across-protocol/constants";
@@ -71,18 +72,24 @@ export class AdapterManager {
         return {};
       } // Special case for the EthereumAdapter
 
-      if (!chainIsEvm(chainId)) {
-        return; // @todo
-      }
-
       return Object.fromEntries(
         SUPPORTED_TOKENS[chainId]?.map((symbol) => {
           const spokePoolClient = spokePoolClients[chainId];
-          assert(isEVMSpokePoolClient(spokePoolClient));
-          const l2Signer = spokePoolClient.spokePool.signer;
+          let l2SignerOrProvider;
+          if (isEVMSpokePoolClient(spokePoolClient)) {
+            l2SignerOrProvider = spokePoolClient.spokePool.signer;
+          } else if (isSVMSpokePoolClient(spokePoolClient)) {
+            l2SignerOrProvider = spokePoolClient.svmEventsClient.getRpc();
+          }
           const l1Token = TOKEN_SYMBOLS_MAP[symbol].addresses[hubChainId];
           const bridgeConstructor = CUSTOM_BRIDGE[chainId]?.[l1Token] ?? CANONICAL_BRIDGE[chainId];
-          const bridge = new bridgeConstructor(chainId, hubChainId, l1Signer, l2Signer, EvmAddress.from(l1Token));
+          const bridge = new bridgeConstructor(
+            chainId,
+            hubChainId,
+            l1Signer,
+            l2SignerOrProvider,
+            EvmAddress.from(l1Token)
+          );
           return [l1Token, bridge];
         }) ?? []
       );
@@ -92,8 +99,10 @@ export class AdapterManager {
         return {};
       }
       const spokePoolClient = spokePoolClients[chainId];
-      assert(isEVMSpokePoolClient(spokePoolClient));
-      const l2Signer = spokePoolClient.spokePool.signer;
+      let l2Signer;
+      if (isEVMSpokePoolClient(spokePoolClient)) {
+        l2Signer = spokePoolClient.spokePool.signer;
+      }
       return Object.fromEntries(
         SUPPORTED_TOKENS[chainId]
           ?.map((symbol) => {
@@ -109,10 +118,6 @@ export class AdapterManager {
       );
     };
     Object.values(this.spokePoolClients).map(({ chainId }) => {
-      if (!chainIsEvm(chainId)) {
-        return; // @todo
-      }
-
       // Instantiate a generic adapter and supply all network-specific configurations.
       this.adapters[chainId] = new BaseChainAdapter(
         spokePoolClients,

src/common/ClientHelper.ts

@@ -219,16 +219,26 @@ export async function constructSpokePoolClientsWithStartBlocks(
   const spokePoolSigners = await getSpokePoolSigners(baseSigner, enabledChains);
   const spokePools = await Promise.all(
     enabledChains.map(async (chainId) => {
-      const spokePoolAddr = hubPoolClient.getSpokePoolForBlock(chainId, toBlockOverride[1]);
-      // TODO: initialize using typechain factory after V3.5 migration.
-      // const spokePoolContract = SpokePool.connect(spokePoolAddr, spokePoolSigners[chainId]);
-      const spokePoolContract = new ethers.Contract(
-        spokePoolAddr,
-        [...SpokePool.abi, ...V3_SPOKE_POOL_ABI],
-        spokePoolSigners[chainId]
+      const registrationBlock = Number(
+        process.env[`REGISTRATION_BLOCK_OVERRIDE_${chainId}`] ??
+          (await resolveSpokePoolActivationBlock(chainId, hubPoolClient, toBlockOverride[1]))
       );
-      const registrationBlock = await resolveSpokePoolActivationBlock(chainId, hubPoolClient, toBlockOverride[1]);
-      return { chainId, contract: spokePoolContract, registrationBlock };
+      // const registrationBlock = await resolveSpokePoolActivationBlock(chainId, hubPoolClient, toBlockOverride[1]);
+      if (chainIsEvm(chainId)) {
+        const spokePoolAddr = hubPoolClient.getSpokePoolForBlock(chainId, toBlockOverride[1]);
+        // TODO: initialize using typechain factory after V3.5 migration.
+        // const spokePoolContract = SpokePool.connect(spokePoolAddr, spokePoolSigners[chainId]);
+        const spokePoolContract = new ethers.Contract(
+          spokePoolAddr,
+          [...SpokePool.abi, ...V3_SPOKE_POOL_ABI],
+          spokePoolSigners[chainId]
+        );
+        return { chainId, contract: spokePoolContract, registrationBlock };
+      } else {
+        // The hub pool client can only return the truncated address of the SVM spoke pool, so if the chain is non-evm, then fallback
+        // to the definitions in the contracts repository.
+        return { chainId, contract: undefined, registrationBlock };
+      }
     })
   );