V5 abis and order types

src/common/abis/deployer.ts

@@ -1,10 +1,17 @@
 import { parseAbi } from "viem";
 
+const _StackItem = `bytes32` as const;
+const _SourceIndexV2 = `uint256` as const;
+const _FullyQualifiedNamespace = `uint256` as const;
+const _EvalV4 =
+    `(address store, ${_FullyQualifiedNamespace} namespace, bytes bytecode, ${_SourceIndexV2} sourceIndex, bytes32[][] context, ${_StackItem}[] inputs, bytes32[] stateOverlay)` as const;
+
 const _deployer = [
     "function parse2(bytes memory data) external view returns (bytes memory bytecode)",
     "function iStore() external view returns (address)",
     "function iInterpreter() external view returns (address)",
     "function iParser() external view returns (address)",
+    `function eval4(${_EvalV4} calldata eval) external view returns (${_StackItem}[] calldata stack, bytes32[] calldata writes)`,
 ] as const;
 
 /** Keeps ExpressionDeployer related ABIs */
@@ -20,4 +27,12 @@ export namespace DeployerAbi {
         /** ExpressionDeployerNPE2 signature ABI */
         export const deployer = _deployer;
     }
+
+    /** Deployer and Interpreter structs ABI */
+    export namespace Structs {
+        export const EvalV4 = _EvalV4;
+        export const StackItem = _StackItem;
+        export const SourceIndexV2 = _SourceIndexV2;
+        export const FullyQualifiedNamespace = _FullyQualifiedNamespace;
+    }
 }

src/core/modes/inter/simulate.test.ts

@@ -142,7 +142,7 @@ describe("Test InterOrderbookTradeSimulator", () => {
                 ).toString(),
             );
             expect(encodeFunctionData).toHaveBeenCalledWith({
-                abi: ABI.Orderbook.Primary.Orderbook,
+                abi: ABI.Orderbook.V4.Primary.Orderbook,
                 functionName: "takeOrders2",
                 args: [
                     {
@@ -217,7 +217,7 @@ describe("Test InterOrderbookTradeSimulator", () => {
             );
             expect(encodeFunctionData).toHaveBeenCalledTimes(1);
             expect(encodeFunctionData).toHaveBeenCalledWith({
-                abi: ABI.Orderbook.Primary.Arb,
+                abi: ABI.Orderbook.V4.Primary.Arb,
                 functionName: "arb3",
                 args: [
                     tradeArgs.orderDetails.orderbook as `0x${string}`,

src/core/modes/inter/simulate.ts

@@ -91,7 +91,7 @@ export class InterOrderbookTradeSimulator extends TradeSimulatorBase {
 
         // encode takeOrders2() and build tx fields
         const encodedFN = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Orderbook,
+            abi: ABI.Orderbook.V4.Primary.Orderbook,
             functionName: "takeOrders2",
             args: [
                 {
@@ -171,7 +171,7 @@ export class InterOrderbookTradeSimulator extends TradeSimulatorBase {
         };
 
         params.rawtx.data = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Arb,
+            abi: ABI.Orderbook.V4.Primary.Arb,
             functionName: "arb3",
             args: [
                 this.tradeArgs.orderDetails.orderbook as `0x${string}`,

src/core/modes/intra/simulation.test.ts

@@ -187,7 +187,7 @@ describe("Test IntraOrderbookTradeSimulator", () => {
             );
             expect(encodeFunctionData).toHaveBeenCalledTimes(4);
             expect(encodeFunctionData).toHaveBeenCalledWith({
-                abi: ABI.Orderbook.Primary.Orderbook,
+                abi: ABI.Orderbook.V4.Primary.Orderbook,
                 functionName: "multicall",
                 args: [["0xencodedData", "0xencodedData", "0xencodedData"]],
             });

src/core/modes/intra/simulation.ts

@@ -128,12 +128,12 @@ export class IntraOrderbookTradeSimulator extends TradeSimulatorBase {
             signedContext: [],
         };
         const withdrawInputCalldata = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Orderbook,
+            abi: ABI.Orderbook.V4.Primary.Orderbook,
             functionName: "withdraw2",
             args: [this.tradeArgs.orderDetails.buyToken, this.inputBountyVaultId, maxUint256, []],
         });
         const withdrawOutputCalldata = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Orderbook,
+            abi: ABI.Orderbook.V4.Primary.Orderbook,
             functionName: "withdraw2",
             args: [
                 this.tradeArgs.orderDetails.sellToken,
@@ -143,7 +143,7 @@ export class IntraOrderbookTradeSimulator extends TradeSimulatorBase {
             ],
         });
         const clear2Calldata = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Orderbook,
+            abi: ABI.Orderbook.V4.Primary.Orderbook,
             functionName: "clear2",
             args: [
                 this.tradeArgs.orderDetails.takeOrder.struct.order,
@@ -169,7 +169,7 @@ export class IntraOrderbookTradeSimulator extends TradeSimulatorBase {
             ],
         });
         params.rawtx.data = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Orderbook,
+            abi: ABI.Orderbook.V4.Primary.Orderbook,
             functionName: "multicall",
             args: [[clear2Calldata, withdrawInputCalldata, withdrawOutputCalldata]],
         });

src/core/modes/router/simulate.test.ts

@@ -342,7 +342,7 @@ describe("Test RouterTradeSimulator", () => {
                 simulator.tradeArgs.solver.state.dispair,
             );
             expect(encodeFunctionData).toHaveBeenCalledWith({
-                abi: ABI.Orderbook.Primary.Arb,
+                abi: ABI.Orderbook.V4.Primary.Arb,
                 functionName: "arb3",
                 args: [
                     tradeArgs.orderDetails.orderbook as `0x${string}`,

src/core/modes/router/simulate.ts

@@ -184,7 +184,7 @@ export class RouterTradeSimulator extends TradeSimulatorBase {
             signedContext: [],
         };
         params.rawtx.data = encodeFunctionData({
-            abi: ABI.Orderbook.Primary.Arb,
+            abi: ABI.Orderbook.V4.Primary.Arb,
             functionName: "arb3",
             args: [
                 this.tradeArgs.orderDetails.orderbook as `0x${string}`,

src/core/process/log.ts

@@ -66,7 +66,7 @@ export function getActualClearAmount(
     } else {
         try {
             const logs = parseEventLogs({
-                abi: [ABI.Orderbook.Primary.Orderbook[2]],
+                abi: [ABI.Orderbook.V4.Primary.Orderbook[2]],
                 eventName: "AfterClear",
                 logs: receipt.logs,
             });

src/core/process/round.ts

@@ -51,19 +51,23 @@ export async function initializeRound(
                 ?.get(owner)
                 ?.get(orderDetails.sellToken)
                 ?.get(
-                    orderDetails.takeOrder.struct.order.validOutputs[
-                        orderDetails.takeOrder.struct.outputIOIndex
-                    ].vaultId,
+                    BigInt(
+                        orderDetails.takeOrder.struct.order.validOutputs[
+                            orderDetails.takeOrder.struct.outputIOIndex
+                        ].vaultId,
+                    ),
                 )?.balance ?? orderDetails.sellTokenVaultBalance;
         orderDetails.buyTokenVaultBalance =
             this.orderManager.ownerTokenVaultMap
                 .get(orderDetails.orderbook)
                 ?.get(owner)
                 ?.get(orderDetails.buyToken)
                 ?.get(
-                    orderDetails.takeOrder.struct.order.validInputs[
-                        orderDetails.takeOrder.struct.inputIOIndex
-                    ].vaultId,
+                    BigInt(
+                        orderDetails.takeOrder.struct.order.validInputs[
+                            orderDetails.takeOrder.struct.inputIOIndex
+                        ].vaultId,
+                    ),
                 )?.balance ?? orderDetails.buyTokenVaultBalance;
 
         // skip if the output vault is empty

src/error/revert.test.ts

@@ -397,11 +397,14 @@ describe("Test revert error handling functions", () => {
 
             expect(result).toBe(frontrunHash);
             expect(decodeFunctionData).toHaveBeenCalledWith({
-                abi: [ABI.Orderbook.Primary.Arb[1]],
+                abi: [ABI.Orderbook.V4.Primary.Arb[1]],
                 data: mockRawTx.data,
             });
             expect(mockViemClient.getLogs).toHaveBeenCalledWith({
-                events: [ABI.Orderbook.Primary.Orderbook[13], ABI.Orderbook.Primary.Orderbook[15]],
+                events: [
+                    ABI.Orderbook.V4.Primary.Orderbook[13],
+                    ABI.Orderbook.V4.Primary.Orderbook[15],
+                ],
                 address: "0xOrderbook",
                 blockHash: mockReceipt.blockHash,
             });
@@ -432,7 +435,7 @@ describe("Test revert error handling functions", () => {
 
             expect(result).toBe(frontrunHash);
             expect(decodeFunctionData).toHaveBeenCalledWith({
-                abi: [ABI.Orderbook.Primary.Orderbook[12]],
+                abi: [ABI.Orderbook.V4.Primary.Orderbook[12]],
                 data: mockRawTx.data,
             });
         });

src/error/revert.ts

@@ -150,14 +150,14 @@ export async function tryDetectFrontrun(
                 if (rawtx.data!.toLowerCase().startsWith("0x7ea0b76a")) {
                     // arb3 trade
                     const result = decodeFunctionData({
-                        abi: [ABI.Orderbook.Primary.Arb[1]],
+                        abi: [ABI.Orderbook.V4.Primary.Arb[1]],
                         data: rawtx.data!,
                     });
                     return (result?.args?.[1] as any)?.orders?.[0];
                 } else {
                     // clear2 trade
                     const result = decodeFunctionData({
-                        abi: [ABI.Orderbook.Primary.Orderbook[12]],
+                        abi: [ABI.Orderbook.V4.Primary.Orderbook[12]],
                         data: rawtx.data!,
                     });
                     return result?.args?.[1];
@@ -173,8 +173,8 @@ export async function tryDetectFrontrun(
             const logs = (
                 await viemClient.getLogs({
                     events: [
-                        ABI.Orderbook.Primary.Orderbook[13],
-                        ABI.Orderbook.Primary.Orderbook[15],
+                        ABI.Orderbook.V4.Primary.Orderbook[13],
+                        ABI.Orderbook.V4.Primary.Orderbook[15],
                     ],
                     address: orderbook,
                     blockHash: receipt.blockHash,

src/order/index.test.ts

@@ -45,13 +45,15 @@ vi.mock("./types", async (importOriginal) => {
     return {
         ...(await importOriginal()),
         Order: {
-            tryFromBytes: vi.fn().mockImplementation((value: any) =>
-                Result.ok({
-                    owner: value === "0xadminBytes" ? "0xadmin" : "0xowner",
-                    validInputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
-                    validOutputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
-                }),
-            ),
+            V3: {
+                tryFromBytes: vi.fn().mockImplementation((value: any) =>
+                    Result.ok({
+                        owner: value === "0xadminBytes" ? "0xadmin" : "0xowner",
+                        validInputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
+                        validOutputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
+                    }),
+                ),
+            },
         },
     };
 });
@@ -274,10 +276,11 @@ describe("Test OrderManager", () => {
             ],
         };
 
-        (Order.tryFromBytes as Mock).mockReturnValueOnce(Result.err("some error"));
+        (Order.V3.tryFromBytes as Mock).mockReturnValueOnce(Result.err("some error"));
         const result = await orderManager.addOrder(order as any);
         assert(result.isErr());
         expect(result.error).instanceOf(OrderManagerError);
+        expect(Order.V3.tryFromBytes).toHaveBeenCalledTimes(1);
 
         const getOrderPairsSpy = vi.spyOn(orderManager, "getOrderPairs");
         getOrderPairsSpy.mockResolvedValueOnce(Result.err(new OrderManagerError("err", 1)));
@@ -633,23 +636,24 @@ describe("Test OrderManager", () => {
             outputs: [{ token: { address: "0xinput", symbol: "IN" }, balance: 1n }],
             inputs: [{ token: { address: "0xoutput", symbol: "OUT" }, balance: 1n }],
         };
-        (Order.tryFromBytes as Mock)
+        (Order.V3.tryFromBytes as Mock)
             .mockReturnValueOnce(
                 Result.ok({
                     owner: "0xowner",
-                    validInputs: [{ token: "0xinput", decimals: 18 }],
-                    validOutputs: [{ token: "0xoutput", decimals: 18 }],
+                    validInputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
+                    validOutputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
                 }),
             )
             .mockReturnValueOnce(
                 Result.ok({
                     owner: "0xowner",
-                    validInputs: [{ token: "0xoutput", decimals: 18 }],
-                    validOutputs: [{ token: "0xinput", decimals: 18 }],
+                    validInputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
+                    validOutputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
                 }),
             );
         await orderManager.addOrder(orderA as any);
         await orderManager.addOrder(orderB as any);
+        expect(Order.V3.tryFromBytes).toHaveBeenCalledTimes(2);
 
         // get a bundled order for orderA (buyToken: 0xinput, sellToken: 0xoutput)
         const roundOrders = orderManager.getNextRoundOrders();
@@ -682,23 +686,24 @@ describe("Test OrderManager", () => {
             outputs: [{ token: { address: "0xinput", symbol: "IN" }, balance: 1n }],
             inputs: [{ token: { address: "0xoutput", symbol: "OUT" }, balance: 1n }],
         };
-        (Order.tryFromBytes as Mock)
+        (Order.V3.tryFromBytes as Mock)
             .mockReturnValueOnce(
                 Result.ok({
                     owner: "0xowner",
-                    validInputs: [{ token: "0xinput", decimals: 18 }],
-                    validOutputs: [{ token: "0xoutput", decimals: 18 }],
+                    validInputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
+                    validOutputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
                 }),
             )
             .mockReturnValueOnce(
                 Result.ok({
                     owner: "0xowner",
-                    validInputs: [{ token: "0xoutput", decimals: 18 }],
-                    validOutputs: [{ token: "0xinput", decimals: 18 }],
+                    validInputs: [{ token: "0xoutput", decimals: 18, vaultId: 1n }],
+                    validOutputs: [{ token: "0xinput", decimals: 18, vaultId: 1n }],
                 }),
             );
         await orderManager.addOrder(orderA as any);
         await orderManager.addOrder(orderB as any);
+        expect(Order.V3.tryFromBytes).toHaveBeenCalledTimes(2);
 
         // get a bundled order for orderA (buyToken: 0xinput, sellToken: 0xoutput)
         const roundOrders = orderManager.getNextRoundOrders();

src/order/index.ts

@@ -10,7 +10,6 @@ import { downscaleProtection } from "./protection";
 import { errorSnapshot, RainSolverBaseError } from "../error";
 import { addToPairMap, removeFromPairMap, getSortedPairList } from "./pair";
 import {
-    IO,
     Pair,
     Order,
     OrderbooksPairMap,
@@ -165,7 +164,7 @@ export class OrderManager {
         const orderHash = orderDetails.orderHash.toLowerCase();
         const orderbook = orderDetails.orderbook.id.toLowerCase();
 
-        const orderStructResult = Order.tryFromBytes(orderDetails.orderBytes);
+        const orderStructResult = Order.V3.tryFromBytes(orderDetails.orderBytes);
         if (orderStructResult.isErr()) {
             return Result.err(
                 new OrderManagerError(
@@ -253,21 +252,21 @@ export class OrderManager {
             owner,
             {
                 address: outputVault.token.toLowerCase(),
-                decimals: outputVault.decimals,
+                decimals: pair.sellTokenDecimals,
                 symbol: pair.sellTokenSymbol,
             },
-            outputVault.vaultId,
+            BigInt(outputVault.vaultId),
             pair.sellTokenVaultBalance,
         );
         this.updateVault(
             orderbook,
             owner,
             {
                 address: inputVault.token.toLowerCase(),
-                decimals: inputVault.decimals,
+                decimals: pair.buyTokenDecimals,
                 symbol: pair.buyTokenSymbol,
             },
-            inputVault.vaultId,
+            BigInt(inputVault.vaultId),
             pair.buyTokenVaultBalance,
         );
     }
@@ -326,7 +325,7 @@ export class OrderManager {
             const orderbook = orderDetails.orderbook.id.toLowerCase();
             const orderHash = orderDetails.orderHash.toLowerCase();
 
-            const orderStructResult = Order.tryFromBytes(orderDetails.orderBytes);
+            const orderStructResult = Order.V3.tryFromBytes(orderDetails.orderBytes);
             if (orderStructResult.isErr()) continue;
 
             const orderStruct = orderStructResult.value;
@@ -381,7 +380,7 @@ export class OrderManager {
      */
     async getOrderPairs(
         orderHash: string,
-        orderStruct: Order,
+        orderStruct: Order.V3,
         orderDetails: SgOrder,
     ): Promise<Result<Pair[], OrderManagerError>> {
         const pairs: Pair[] = [];
@@ -401,7 +400,7 @@ export class OrderManager {
 
         // helper function to handle token details
         const handleToken = async (
-            io: IO,
+            io: Order.V3.IO,
             tokensList: SgOrder["outputs"],
         ): Promise<
             Result<{ symbol: string; decimals: number; balance: string }, OrderManagerError>