feat: track in-progress set max reserve

* chore: update schema

* chore: extend vaultService

* chore: add syncManager tracking

* chore: fix type networknames

* chore: sync manager only in v3_1

* chore: improved typing

* fix: message decoding for single version registry

* feat: track inprogress set max reserve

* chore: init vault with max reserve possible

Author: filo87

ponder.config.ts

@@ -82,6 +82,7 @@ export const contractsV3_1 = decorateDeploymentContracts(
     "ShareClassManager",
     "Spoke",
     "VaultRegistry",
+    "SyncManager",
   ] as const,
   {
     vaultV3_1: {

ponder.schema.ts

@@ -179,7 +179,7 @@ export const VaultKinds = ["Async", "Sync", "SyncDepositAsyncRedeem"] as const;
 export const VaultKind = onchainEnum("vault_kind", VaultKinds);
 export const VaultStatuses = ["LinkInProgress", "UnlinkInProgress", "Linked", "Unlinked"] as const;
 export const VaultStatus = onchainEnum("vault_status", VaultStatuses);
-export const VaultCrosschainInProgressTypes = [`Deploy`, `Link`, `Unlink`] as const;
+export const VaultCrosschainInProgressTypes = [`Deploy`, `Link`, `Unlink`, `MaxReserve`] as const;
 export const VaultCrosschainInProgress = onchainEnum(
   "vault_crosschain_in_progress",
   VaultCrosschainInProgressTypes
@@ -196,7 +196,9 @@ const VaultColumns = (t: PgColumnsBuilders) => ({
   assetAddress: t.hex(),
   factory: t.text(),
   manager: t.text(),
+  maxReserve: t.bigint().default(0n),
   crosschainInProgress: VaultCrosschainInProgress("vault_crosschain_in_progress"),
+  crosschainInProgressValue: t.bigint(),
   ...defaultColumns(t),
 });
 export const Vault = onchainTable("vault", VaultColumns, (t) => ({

src/chains.ts

@@ -41,7 +41,7 @@ type ExtractNetworkNamesFromKeys<K> = K extends keyof typeof networkNames
   ? (typeof networkNames)[K]
   : never;
 
-export type NetworkNames<V> = V extends RegistryVersions
+export type NetworkNames<V extends RegistryVersions> = V extends RegistryVersions
   ? ExtractNetworkNamesFromKeys<RegistryChainsKeys<V>>
   : never;
 

src/handlers/hubHandlers.ts

@@ -8,6 +8,7 @@ import {
   AccountService,
   centrifugeIdFromAssetId,
   VaultService,
+  AssetService,
 } from "../services";
 import { VaultCrosschainInProgressTypes } from "ponder:schema";
 
@@ -132,6 +133,33 @@ multiMapper("hub:UpdateVault", async ({ event, context }) => {
   await vault.setCrosschainInProgress(vaultUpdateKind).save(event);
 });
 
+multiMapper("hub:UpdateContract", async ({ event, context }) => {
+  logEvent(event, context, "hub:UpdateContract");
+  const { centrifugeId: destCentrifugeId, poolId, scId: tokenId, payload } = event.args;
+
+  const decoded = decodeUpdateContract(payload);
+  if (!decoded || !decoded.payload)
+    return serviceError(`Invalid update contract payload: ${payload}`);
+
+  if (decoded.kind === "MaxReserve" && "maxReserve" in decoded.payload) {
+    const { assetId, maxReserve } = decoded.payload as { assetId: bigint; maxReserve: bigint };
+    const asset = await AssetService.get(context, { id: assetId });
+    if (!asset)
+      return serviceError(`Asset not found for assetId ${assetId}. Cannot update vault maxReserve`);
+    const assetAddress = asset.read().address as `0x${string}`;
+    if (!assetAddress) return serviceError(`Asset has no address for assetId ${assetId}`);
+
+    const vault = (await VaultService.get(context, {
+      centrifugeId: destCentrifugeId.toString(),
+      poolId,
+      tokenId,
+      assetAddress,
+    })) as VaultService | null;
+    if (!vault) return serviceError(`Vault not found. Cannot update maxReserve`);
+    await vault.setMaxReserve(maxReserve).setCrosschainInProgress().save(event);
+  }
+});
+
 enum RestrictionType {
   "Invalid",
   "Member",
@@ -148,7 +176,7 @@ function decodeUpdateRestriction(
   payload: `0x${string}`
 ):
   | [
-      restrictionType: RestrictionType.Member | RestrictionType.Freeze | RestrictionType.Unfreeze,
+      restrictionType: (typeof RestrictionType)[keyof typeof RestrictionType],
       accountAddress: `0x${string}`,
       validUntil: Date | null,
     ]
@@ -172,3 +200,153 @@ function decodeUpdateRestriction(
       return null;
   }
 }
+
+// ---------------------------------------------------------------------------
+// UpdateContract: single-pass decoding (SyncManager, OnOfframpManager, BaseTransferHook)
+// ---------------------------------------------------------------------------
+
+/** ABI word size. Solidity abi.encode uses 32-byte words; uint8/uint128/bool are right-aligned. */
+const WORD_SIZE = 32;
+/** Start offset of word N (0-based). */
+const word = (n: number) => n * WORD_SIZE;
+/** Decode a value from the 32-byte ABI word at wordIndex using the given decoder. */
+function decodeAtWord<T>(buffer: Buffer, wordIndex: number, decoder: (chunk: Buffer) => T): T {
+  const start = wordIndex * WORD_SIZE;
+  return decoder(buffer.subarray(start, start + WORD_SIZE));
+}
+/** Decoder: right-aligned uint8 in a 32-byte word (bytes 31). */
+const decodeUint8InWord = (chunk: Buffer): number => chunk.readUInt8(WORD_SIZE - 1);
+/** Decoder: right-aligned uint128 in a 32-byte word (bytes 16–31). */
+const decodeUint128InWord = (chunk: Buffer): bigint =>
+  chunk.readBigUInt64BE(16) | (chunk.readBigUInt64BE(24) << 64n);
+/** Decoder: bytes32 as 20-byte address (right-padded, bytes 12–31). */
+const decodeBytes32Address = (chunk: Buffer): `0x${string}` =>
+  `0x${chunk.subarray(12, 32).toString("hex")}` as `0x${string}`;
+/** Payload kind (uint8) in UpdateContract; matches SyncManager / OnOfframpManager / BaseTransferHook TrustedCall. */
+enum UpdateContractPayloadKind {
+  "Valuation", // SyncManager.Valuation | OnOfframpManager.Onramp | BaseTransferHook.UpdateHookManager
+  "MaxReserve", // SyncManager.MaxReserve | OnOfframpManager.Relayer
+  "Offramp", // OnOfframpManager.Offramp
+  "Withdraw", // OnOfframpManager.Withdraw
+}
+
+/** All possible decoded payloads from protocol UpdateContract, by kind. Payload is null when shape is unrecognized. */
+export type DecodedUpdateContract =
+  | {
+      kind: "Valuation";
+      payload:
+        | { valuation: `0x${string}` } // SyncManager
+        | { assetId: bigint; isEnabled: boolean } // OnOfframpManager.Onramp
+        | { manager: `0x${string}`; canManage: boolean } // BaseTransferHook.UpdateHookManager
+        | null;
+    }
+  | {
+      kind: "MaxReserve";
+      payload:
+        | { assetId: bigint; maxReserve: bigint } // SyncManager
+        | { relayerAddress: `0x${string}`; isEnabled: boolean } // OnOfframpManager.Relayer
+        | null;
+    }
+  | {
+      kind: "Offramp";
+      payload:
+        | { assetId: bigint; receiverAddress: `0x${string}`; isEnabled: boolean } // OnOfframpManager.Offramp
+        | null;
+    }
+  | {
+      kind: "Withdraw";
+      payload:
+        | { assetId: bigint; amount: bigint; receiverAddress: `0x${string}` } // OnOfframpManager.Withdraw
+        | null;
+    };
+
+/** True if word at index looks like a right-aligned uint128 (bytes 0–15 zero). */
+function isWordZeroPaddedUint128(b: Buffer, wordIndex: number): boolean {
+  const start = wordIndex * WORD_SIZE;
+  for (let i = 0; i < 16; i++) if (b[start + i] !== 0) return false;
+  return true;
+}
+
+/**
+ * Decodes the update contract payload into its parameters.
+ * Does not resolve target address; decoding is based only on payload kind and shape.
+ * @param payload - The payload to decode.
+ * @returns The decoded parameters.
+ */
+export function decodeUpdateContract(payload: `0x${string}`): DecodedUpdateContract | null {
+  const b = Buffer.from(payload.slice(2), "hex");
+  if (b.length < WORD_SIZE) return null;
+  const kindValue = decodeAtWord(b, 0, decodeUint8InWord);
+  const kind = Object.keys(UpdateContractPayloadKind)[kindValue] as
+    | keyof typeof UpdateContractPayloadKind
+    | undefined;
+  if (kind === undefined) return null;
+
+  const result: DecodedUpdateContract = {
+    kind,
+    payload: null,
+  };
+
+  // ABI layout: each slot is 32 bytes; uint8/uint128/bool right-aligned.
+  switch (kind) {
+    case "Valuation":
+      // (uint8, bytes32) = 2 words — SyncManager only
+      if (b.length === word(2)) {
+        result.payload = {
+          valuation: decodeAtWord(b, 1, decodeBytes32Address),
+        };
+      }
+      // (uint8, uint128, bool) = 3 words (Onramp) | (uint8, bytes32, bool) = 3 words (UpdateHookManager)
+      if (b.length === word(3) && isWordZeroPaddedUint128(b, 1)) {
+        result.payload = {
+          assetId: decodeAtWord(b, 1, decodeUint128InWord),
+          isEnabled: decodeAtWord(b, 2, decodeUint8InWord) !== 0,
+        };
+      }
+      if (b.length === word(3) && !isWordZeroPaddedUint128(b, 1)) {
+        result.payload = {
+          manager: decodeAtWord(b, 1, decodeBytes32Address),
+          canManage: decodeAtWord(b, 2, decodeUint8InWord) !== 0,
+        };
+      }
+      break;
+    case "MaxReserve":
+      // (uint8, uint128, uint128) = 3 words (SyncManager) | (uint8, bytes32, bool) = 3 words (Relayer)
+      if (b.length === word(3)) {
+        if (isWordZeroPaddedUint128(b, 1) && isWordZeroPaddedUint128(b, 2)) {
+          result.payload = {
+            assetId: decodeAtWord(b, 1, decodeUint128InWord),
+            maxReserve: decodeAtWord(b, 2, decodeUint128InWord),
+          };
+        } else {
+          result.payload = {
+            relayerAddress: decodeAtWord(b, 1, decodeBytes32Address),
+            isEnabled: decodeAtWord(b, 2, decodeUint8InWord) !== 0,
+          };
+        }
+      }
+      break;
+    case "Offramp":
+      // (uint8, uint128, bytes32, bool) = 4 words
+      if (b.length === word(4)) {
+        result.payload = {
+          assetId: decodeAtWord(b, 1, decodeUint128InWord),
+          receiverAddress: decodeAtWord(b, 2, decodeBytes32Address),
+          isEnabled: decodeAtWord(b, 3, decodeUint8InWord) !== 0,
+        };
+      }
+      break;
+    case "Withdraw":
+      // (uint8, uint128, uint128, bytes32) = 4 words
+      if (b.length === word(4)) {
+        result.payload = {
+          assetId: decodeAtWord(b, 1, decodeUint128InWord),
+          amount: decodeAtWord(b, 2, decodeUint128InWord),
+          receiverAddress: decodeAtWord(b, 3, decodeBytes32Address),
+        };
+      }
+      break;
+  }
+
+  return result;
+}

src/handlers/vaultHandlers.ts

@@ -1,5 +1,5 @@
 import { multiMapper } from "../helpers/multiMapper";
-import { logEvent, serviceError } from "../helpers/logger";
+import { logEvent, serviceError, serviceLog } from "../helpers/logger";
 import {
   AccountService,
   AssetService,
@@ -588,3 +588,26 @@ function getSharePrice(
   if (sharesAmount === 0n) return null;
   return (assetsAmount * 10n ** BigInt(18 - assetDecimals + shareDecimals)) / sharesAmount;
 }
+
+multiMapper("syncManager:SetMaxReserve", async ({ event, context }) => {
+  logEvent(event, context, "syncManager:SetMaxReserve");
+  const centrifugeId = await BlockchainService.getCentrifugeId(context);
+  const {
+    poolId,
+    scId: tokenId,
+    asset: assetAddress,
+    tokenId: _assetTokenId,
+    maxReserve,
+  } = event.args;
+
+  const vault = (await VaultService.get(context, {
+    centrifugeId,
+    poolId,
+    tokenId,
+    assetAddress,
+  })) as VaultService | null;
+  if (!vault)
+    return serviceLog(`Vault not found. Cannot retrieve vault. Maybe it's not deployed yet?`);
+
+  await vault.setMaxReserve(maxReserve).setCrosschainInProgress().save(event);
+});

src/handlers/vaultRegistryHandlers.ts

@@ -64,6 +64,7 @@ export async function deployVault({
       isActive: true,
       status: "Unlinked",
       crosschainInProgress: null,
+      maxReserve: 2n ** 128n - 1n,
     },
     event
   )) as VaultService;

src/helpers/formatter.ts

@@ -18,3 +18,13 @@ export function formatBigIntToDecimal(value: bigint, decimals: number = 18): str
 
   return `${integerStr}.${remainderStr}`;
 }
+
+/**
+ * Formats a bytes32 value as a 0x address.
+ *
+ * @param value - The bytes32 value to format
+ * @returns The formatted 0x address
+ */
+export function formatBytes32ToAddress(value: `0x${string}`): `0x${string}` {
+  return value.substring(0, 42).toLowerCase() as `0x${string}`;
+}

src/services/VaultService.ts

@@ -40,10 +40,26 @@ export class VaultService extends mixinCommonStatics(Service<typeof Vault>, Vaul
    * @returns The service instance for method chaining
    */
   public setCrosschainInProgress(
-    crosschainInProgress?: (typeof VaultCrosschainInProgressTypes)[number]
+    crosschainInProgress?: (typeof VaultCrosschainInProgressTypes)[number],
+    crosschainInProgressValue?: bigint
   ) {
     this.data.crosschainInProgress = crosschainInProgress ?? null;
-    serviceLog(`Setting crosschainInProgress to ${crosschainInProgress}`);
+    this.data.crosschainInProgressValue = crosschainInProgressValue ?? null;
+    serviceLog(
+      `Setting crosschainInProgress to ${crosschainInProgress} with value ${crosschainInProgressValue}`
+    );
+    return this;
+  }
+
+  /**
+   * Sets the max reserve for the vault.
+   *
+   * @param maxReserve - The value to set for maxReserve
+   * @returns The service instance for method chaining
+   */
+  public setMaxReserve(maxReserve: bigint) {
+    this.data.maxReserve = maxReserve;
+    serviceLog(`Setting maxReserve to ${maxReserve}`);
     return this;
   }
 }