@oydual31/more-vaults-sdk 0.3.3 → 0.4.1

package/src/ethers/crossChainFlows.ts

@@ -1,6 +1,9 @@
 import { Contract, AbiCoder, zeroPadValue, Signer, Provider } from "ethers";
 import { ERC20_ABI, OFT_ABI, BRIDGE_ABI, LZ_ENDPOINT_ABI } from "./abis";
 import type { ContractTransactionReceipt } from "ethers";
+import { EID_TO_CHAIN_ID, OFT_ROUTES, createChainProvider } from "./chains";
+import { detectStargateOft } from "./utils";
+import { OMNI_FACTORY_ADDRESS } from "./topology";
 
 /** LZ Endpoint V2 address — same on all EVM chains */
 const LZ_ENDPOINT = "0x1a44076050125825900e736c501f859c50fe728c";
@@ -309,3 +312,208 @@ export async function executeCompose(
 
   return { receipt };
 }
+
+// ---------------------------------------------------------------------------
+// Compose data types and waitForCompose
+// ---------------------------------------------------------------------------
+
+/**
+ * Data needed to execute a pending LZ compose on the hub chain.
+ * Returned by `depositFromSpoke` when the OFT is a Stargate V2 pool.
+ * The SDK user must call `executeCompose()` with this data as TX2 on the hub.
+ */
+export interface ComposeData {
+  /** LZ Endpoint address on the hub chain */
+  endpoint: string
+  /** The OFT/pool address that sent the compose (Stargate pool on hub) — resolved by waitForCompose */
+  from: string
+  /** MoreVaultsComposer address on the hub */
+  to: string
+  /** LayerZero GUID from the original OFT.send() */
+  guid: string
+  /** Compose index (default 0) */
+  index: number
+  /** Full compose message bytes — resolved by waitForCompose from ComposeSent event */
+  message: string
+  /** Whether this is a Stargate OFT (2-TX flow) */
+  isStargate: boolean
+  /** Hub chain ID */
+  hubChainId: number
+  /** Block number on hub chain right before depositFromSpoke TX — used to bound event scan */
+  hubBlockStart: bigint
+}
+
+/** Minimal ABIs for helper functions used only in this file */
+const FACTORY_COMPOSER_ABI_MIN = [
+  "function vaultComposer(address _vault) view returns (address)",
+] as const;
+
+const COMPOSER_SHARE_OFT_ABI = [
+  "function SHARE_OFT() view returns (address)",
+] as const;
+
+const OFT_PEERS_ABI = [
+  "function peers(uint32 eid) view returns (bytes32)",
+] as const;
+
+const OFT_TOKEN_ABI = [
+  "function token() view returns (address)",
+] as const;
+
+const OFT_QUOTE_OFT_ABI = [
+  "function quoteOFT(tuple(uint32 dstEid, bytes32 to, uint256 amountLD, uint256 minAmountLD, bytes extraOptions, bytes composeMsg, bytes oftCmd) sendParam) view returns (tuple(uint256 minAmountLD, uint256 maxAmountLD), tuple(int256 feeAmountLD, string description)[], tuple(uint256 amountSentLD, uint256 amountReceivedLD))",
+] as const;
+
+/**
+ * Wait for a pending compose to appear in the LZ Endpoint's composeQueue on the hub chain.
+ *
+ * After `depositFromSpoke` sends tokens via Stargate, the LZ network delivers the message
+ * to the hub chain. The endpoint stores the compose hash in `composeQueue` and emits
+ * a `ComposeSent` event with the full message bytes.
+ *
+ * Strategy: scan ComposeSent events on the LZ Endpoint starting from `hubBlockStart`
+ * (captured by `depositFromSpoke` right before TX1). We scan forward in 500-block chunks,
+ * matching by composer address and receiver in the message body.
+ *
+ * @param hubProvider      Read-only provider on the HUB chain
+ * @param composeData      Partial compose data (includes hubBlockStart, to, guid)
+ * @param receiver         Receiver address to match in the compose message
+ * @param pollIntervalMs   Polling interval (default 20s)
+ * @param timeoutMs        Timeout (default 30 min)
+ * @returns                Complete ComposeData ready for executeCompose
+ */
+export async function waitForCompose(
+  hubProvider: Provider,
+  composeData: ComposeData,
+  receiver: string,
+  pollIntervalMs = 20_000,
+  timeoutMs = 1_800_000,
+): Promise<ComposeData> {
+  const deadline = Date.now() + timeoutMs
+  const composer = composeData.to.toLowerCase()
+  const endpoint = composeData.endpoint
+  const receiverNeedle = receiver.replace(/^0x/, '').toLowerCase()
+  const startBlock = composeData.hubBlockStart
+
+  // Collect Stargate OFT addresses on the hub chain
+  const hubChainId = composeData.hubChainId
+  const candidateAddresses: string[] = []
+  for (const chainMap of Object.values(OFT_ROUTES)) {
+    const entry = (chainMap as Record<number, { oft: string; token: string }>)[hubChainId]
+    if (entry) candidateAddresses.push(entry.oft.toLowerCase())
+  }
+
+  // Filter to Stargate addresses on-chain
+  const stargateChecks = await Promise.all(
+    candidateAddresses.map(async (addr) => ({
+      addr,
+      isSg: await detectStargateOft(hubProvider, addr),
+    })),
+  )
+  const knownFromAddresses = stargateChecks.filter((c) => c.isSg).map((c) => c.addr)
+
+  // ComposeSent event ABI for getLogs
+  const endpointContract = new Contract(endpoint, LZ_ENDPOINT_ABI, hubProvider)
+
+  // ComposeSent event topic
+  const COMPOSE_SENT_TOPIC = "0x0c68e6a0b0fb0f33c52455a8da89b21fc640a3dd4a1b21d9bfcc8aeee4a43e84"
+
+  let attempt = 0
+  let scannedUpTo = startBlock - 1n
+
+  while (Date.now() < deadline) {
+    attempt++
+    const elapsed = Math.round((Date.now() - (deadline - timeoutMs)) / 1000)
+
+    try {
+      const currentBlock = BigInt(await hubProvider.getBlockNumber())
+      const chunkSize = 500n
+      let from = scannedUpTo + 1n
+
+      while (from <= currentBlock) {
+        const chunkEnd = from + chunkSize > currentBlock ? currentBlock : from + chunkSize
+
+        try {
+          const logs = await hubProvider.getLogs({
+            address: endpoint,
+            topics: [COMPOSE_SENT_TOPIC],
+            fromBlock: `0x${from.toString(16)}`,
+            toBlock: `0x${chunkEnd.toString(16)}`,
+          })
+
+          for (const log of logs) {
+            // ComposeSent(address from, address to, bytes32 guid, uint16 index, bytes message)
+            // All params are non-indexed — decode from data
+            try {
+              const coder = AbiCoder.defaultAbiCoder()
+              const decoded = coder.decode(
+                ['address', 'address', 'bytes32', 'uint16', 'bytes'],
+                log.data,
+              )
+              const logFrom = (decoded[0] as string).toLowerCase()
+              const logTo = (decoded[1] as string).toLowerCase()
+              const logGuid = decoded[2] as string
+              const logIndex = Number(decoded[3])
+              const logMessage = decoded[4] as string
+
+              if (
+                logTo === composer &&
+                logMessage.toLowerCase().includes(receiverNeedle)
+              ) {
+                // Verify this compose is still pending in composeQueue
+                const hash: string = await endpointContract.composeQueue(
+                  logFrom, composer, logGuid, logIndex,
+                )
+
+                if (hash !== EMPTY_HASH && hash !== RECEIVED_HASH) {
+                  console.log(`[${elapsed}s] Poll #${attempt} — compose found! (block ${log.blockNumber})`)
+                  return {
+                    ...composeData,
+                    from: decoded[0] as string,
+                    to: composeData.to,
+                    guid: logGuid,
+                    index: logIndex,
+                    message: logMessage,
+                  }
+                }
+              }
+            } catch { /* decode failed — skip log */ }
+          }
+        } catch {
+          // Chunk failed (RPC limit) — break inner loop, will retry next poll
+          break
+        }
+
+        from = chunkEnd + 1n
+      }
+
+      scannedUpTo = currentBlock
+    } catch {
+      // getBlockNumber failed — retry next poll
+    }
+
+    // Also try composeQueue directly with spoke GUID (works when GUIDs match)
+    let guidMatchFound = false
+    for (const fromAddr of knownFromAddresses) {
+      try {
+        const hash: string = await endpointContract.composeQueue(
+          fromAddr, composer, composeData.guid, 0,
+        )
+        if (hash !== EMPTY_HASH && hash !== RECEIVED_HASH) {
+          console.log(`[${elapsed}s] Poll #${attempt} — composeQueue confirms pending (GUID match), re-scanning for message...`)
+          scannedUpTo = startBlock - 1n
+          guidMatchFound = true
+        }
+      } catch { /* continue */ }
+    }
+
+    if (!guidMatchFound) {
+      console.log(`[${elapsed}s] Poll #${attempt} — compose not found yet, waiting ${pollIntervalMs / 1000}s...`)
+    }
+    await new Promise(resolve => setTimeout(resolve, pollIntervalMs))
+  }
+
+  throw new Error(
+    `Timeout waiting for compose after ${timeoutMs / 60_000} min. Check LayerZero scan for composer ${composeData.to}.`,
+  )
+}

package/src/ethers/curatorMulticall.ts

@@ -0,0 +1,195 @@
+/**
+ * Curator MulticallFacet write operations for the MoreVaults ethers.js v6 SDK.
+ *
+ * Provides typed helpers to submit, execute, and veto curator action batches
+ * on any MoreVaults diamond that has the MulticallFacet installed.
+ *
+ * @module curatorMulticall
+ */
+
+import { Contract, Interface } from "ethers";
+import type { Signer, ContractTransactionReceipt } from "ethers";
+import {
+  MULTICALL_ABI,
+  DEX_ABI,
+  ERC7540_FACET_ABI,
+  ERC4626_FACET_ABI,
+} from "./abis";
+import type { CuratorAction, SubmitActionsResult } from "./types";
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Encoding helpers
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Encode a single typed CuratorAction into raw calldata bytes suitable for
+ * passing into `submitActions(bytes[] actionsData)`.
+ *
+ * The encoded bytes are the full ABI-encoded function call (4-byte selector +
+ * arguments) targeting the vault diamond itself — the MulticallFacet will
+ * call `address(this).call(actionsData[i])` for each entry.
+ *
+ * @param action  A discriminated-union CuratorAction describing what to do
+ * @returns       ABI-encoded calldata hex string
+ */
+export function encodeCuratorAction(action: CuratorAction): string {
+  switch (action.type) {
+    case 'swap': {
+      const iface = new Interface(DEX_ABI as unknown as string[]);
+      return iface.encodeFunctionData("executeSwap", [
+        {
+          targetContract: action.params.targetContract,
+          tokenIn: action.params.tokenIn,
+          tokenOut: action.params.tokenOut,
+          maxAmountIn: action.params.maxAmountIn,
+          minAmountOut: action.params.minAmountOut,
+          swapCallData: action.params.swapCallData,
+        },
+      ]);
+    }
+
+    case 'batchSwap': {
+      const iface = new Interface(DEX_ABI as unknown as string[]);
+      return iface.encodeFunctionData("executeBatchSwap", [
+        {
+          swaps: action.params.swaps.map((s) => ({
+            targetContract: s.targetContract,
+            tokenIn: s.tokenIn,
+            tokenOut: s.tokenOut,
+            maxAmountIn: s.maxAmountIn,
+            minAmountOut: s.minAmountOut,
+            swapCallData: s.swapCallData,
+          })),
+        },
+      ]);
+    }
+
+    case 'erc4626Deposit': {
+      const iface = new Interface(ERC4626_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc4626Deposit", [action.vault, action.assets]);
+    }
+
+    case 'erc4626Redeem': {
+      const iface = new Interface(ERC4626_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc4626Redeem", [action.vault, action.shares]);
+    }
+
+    case 'erc7540RequestDeposit': {
+      const iface = new Interface(ERC7540_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc7540RequestDeposit", [action.vault, action.assets]);
+    }
+
+    case 'erc7540Deposit': {
+      const iface = new Interface(ERC7540_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc7540Deposit", [action.vault, action.assets]);
+    }
+
+    case 'erc7540RequestRedeem': {
+      const iface = new Interface(ERC7540_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc7540RequestRedeem", [action.vault, action.shares]);
+    }
+
+    case 'erc7540Redeem': {
+      const iface = new Interface(ERC7540_FACET_ABI as unknown as string[]);
+      return iface.encodeFunctionData("erc7540Redeem", [action.vault, action.shares]);
+    }
+
+    default: {
+      // TypeScript exhaustiveness check — this branch is never reached at runtime
+      const _exhaustive: never = action;
+      throw new Error(`[MoreVaults] Unknown CuratorAction type: ${(_exhaustive as any).type}`);
+    }
+  }
+}
+
+/**
+ * Encode an array of CuratorActions into a calldata array ready for
+ * `submitActions`.
+ *
+ * @param actions  Array of typed CuratorAction objects
+ * @returns        Array of ABI-encoded calldata hex strings
+ */
+export function buildCuratorBatch(actions: CuratorAction[]): string[] {
+  return actions.map(encodeCuratorAction);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Write operations
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Submit a batch of curator actions to the vault's MulticallFacet.
+ *
+ * When `timeLockPeriod == 0` the contract immediately executes the actions
+ * inside `submitActions` itself. When a timelock is configured the actions
+ * are queued and must be executed later with `executeActions`.
+ *
+ * After the write succeeds, reads `getCurrentNonce` to determine which nonce
+ * was assigned (nonce - 1 after the submit increments it).
+ *
+ * @param signer   Signer with curator account attached
+ * @param vault    Vault address (diamond proxy)
+ * @param actions  Array of raw calldata bytes — use `buildCuratorBatch` to build
+ * @returns        Receipt and the nonce assigned to this batch
+ */
+export async function submitActions(
+  signer: Signer,
+  vault: string,
+  actions: string[]
+): Promise<SubmitActionsResult> {
+  const multicallContract = new Contract(vault, MULTICALL_ABI, signer);
+
+  const tx = await multicallContract.submitActions(actions);
+  const receipt: ContractTransactionReceipt = await tx.wait();
+
+  // Read the nonce that was assigned: the contract increments actionNonce after storing,
+  // so getCurrentNonce now returns (assignedNonce + 1). Subtract 1 to recover it.
+  const nextNonce = (await multicallContract.getCurrentNonce()) as bigint;
+  const nonce = nextNonce - 1n;
+
+  return { receipt, nonce };
+}
+
+/**
+ * Execute pending actions after their timelock period has expired.
+ *
+ * Can only be called when `block.timestamp >= pendingUntil`. The contract
+ * reverts with `ActionsStillPending` if the timelock has not expired.
+ *
+ * @param signer  Signer with curator account attached
+ * @param vault   Vault address (diamond proxy)
+ * @param nonce   The action batch nonce to execute
+ * @returns       Transaction receipt
+ */
+export async function executeActions(
+  signer: Signer,
+  vault: string,
+  nonce: bigint
+): Promise<ContractTransactionReceipt> {
+  const multicallContract = new Contract(vault, MULTICALL_ABI, signer);
+
+  const tx = await multicallContract.executeActions(nonce);
+  return tx.wait() as Promise<ContractTransactionReceipt>;
+}
+
+/**
+ * Guardian-only: cancel (veto) one or more pending action batches.
+ *
+ * Deletes the pending actions from storage, preventing them from ever being
+ * executed. Only the vault guardian can call this.
+ *
+ * @param signer   Signer with guardian account attached
+ * @param vault    Vault address (diamond proxy)
+ * @param nonces   Array of action nonces to cancel
+ * @returns        Transaction receipt
+ */
+export async function vetoActions(
+  signer: Signer,
+  vault: string,
+  nonces: bigint[]
+): Promise<ContractTransactionReceipt> {
+  const multicallContract = new Contract(vault, MULTICALL_ABI, signer);
+
+  const tx = await multicallContract.vetoActions(nonces);
+  return tx.wait() as Promise<ContractTransactionReceipt>;
+}