feat: add contract remediation changes

.changeset/chatty-rice-beam.md

@@ -0,0 +1,5 @@
+---
+"@rhinestone/sdk": patch
+---
+
+contract remediation changes

src/execution/compact.ts

@@ -25,10 +25,9 @@ const COMPACT_TYPED_DATA_TYPES = {
   ],
   Mandate: [
     { name: 'target', type: 'Target' },
-    { name: 'v', type: 'uint8' },
     { name: 'minGas', type: 'uint128' },
-    { name: 'originOps', type: 'Op[]' },
-    { name: 'destOps', type: 'Op[]' },
+    { name: 'originOps', type: 'Op' },
+    { name: 'destOps', type: 'Op' },
     { name: 'q', type: 'bytes32' },
   ],
   Target: [
@@ -42,6 +41,10 @@ const COMPACT_TYPED_DATA_TYPES = {
     { name: 'amount', type: 'uint256' },
   ],
   Op: [
+    { name: 'vt', type: 'bytes32' },
+    { name: 'ops', type: 'Ops[]' },
+  ],
+  Ops: [
     { name: 'to', type: 'address' },
     { name: 'value', type: 'uint256' },
     { name: 'data', type: 'bytes' },
@@ -80,18 +83,9 @@ function getCompactTypedData(intentOp: IntentOp) {
             targetChain: BigInt(element.mandate.destinationChainId),
             fillExpiry: BigInt(element.mandate.fillDeadline),
           },
-          v: element.mandate.v,
           minGas: BigInt(element.mandate.minGas),
-          originOps: element.mandate.preClaimOps.map((op) => ({
-            to: op.to,
-            value: BigInt(op.value),
-            data: op.data,
-          })),
-          destOps: element.mandate.destinationOps.map((op) => ({
-            to: op.to,
-            value: BigInt(op.value),
-            data: op.data,
-          })),
+          originOps: element.mandate.preClaimOps,
+          destOps: element.mandate.destinationOps,
           q: keccak256(element.mandate.qualifier.encodedVal),
         },
       })),

src/execution/permit2.ts

@@ -63,17 +63,20 @@ function getTypedData(
         { name: 'targetChain', type: 'uint256' },
         { name: 'fillExpiry', type: 'uint256' },
       ],
-      Op: [
+      Ops: [
         { name: 'to', type: 'address' },
         { name: 'value', type: 'uint256' },
         { name: 'data', type: 'bytes' },
       ],
+      Op: [
+        { name: 'vt', type: 'bytes32' },
+        { name: 'ops', type: 'Ops[]' },
+      ],
       Mandate: [
         { name: 'target', type: 'Target' },
-        { name: 'v', type: 'uint8' },
         { name: 'minGas', type: 'uint128' },
-        { name: 'originOps', type: 'Op[]' },
-        { name: 'destOps', type: 'Op[]' },
+        { name: 'originOps', type: 'Op' },
+        { name: 'destOps', type: 'Op' },
         { name: 'q', type: 'bytes32' },
       ],
       PermitBatchWitnessTransferFrom: [
@@ -100,18 +103,9 @@ function getTypedData(
           targetChain: BigInt(mandate.destinationChainId),
           fillExpiry: BigInt(mandate.fillDeadline),
         },
-        v: mandate.v,
         minGas: BigInt(mandate.minGas),
-        originOps: mandate.preClaimOps.map((op) => ({
-          to: op.to,
-          value: BigInt(op.value),
-          data: op.data,
-        })),
-        destOps: mandate.destinationOps.map((op) => ({
-          to: op.to,
-          value: BigInt(op.value),
-          data: op.data,
-        })),
+        originOps: mandate.preClaimOps,
+        destOps: mandate.destinationOps,
         q: keccak256(mandate.qualifier.encodedVal),
       },
     },

src/execution/singleChainOps.ts

@@ -1,14 +1,12 @@
-import type { Address } from 'viem'
-import type { Execution, IntentOpElement } from '../orchestrator/types'
+import { type Address, zeroAddress } from 'viem'
+import type { IntentOpElement } from '../orchestrator/types'
 
 function getTypedData(
   account: Address,
   intentExecutorAddress: Address,
   element: IntentOpElement,
   nonce: bigint,
 ) {
-  const ops: Execution[] = element.mandate.destinationOps
-
   return {
     domain: {
       name: 'IntentExecutor',
@@ -20,9 +18,18 @@ function getTypedData(
       SingleChainOps: [
         { name: 'account', type: 'address' },
         { name: 'nonce', type: 'uint256' },
-        { name: 'ops', type: 'Op[]' },
+        { name: 'op', type: 'Op' },
+        { name: 'gasRefund', type: 'GasRefund' },
       ],
       Op: [
+        { name: 'vt', type: 'bytes32' },
+        { name: 'ops', type: 'Ops[]' },
+      ],
+      GasRefund: [
+        { name: 'token', type: 'address' },
+        { name: 'exchangeRate', type: 'uint256' },
+      ],
+      Ops: [
         { name: 'to', type: 'address' },
         { name: 'value', type: 'uint256' },
         { name: 'data', type: 'bytes' },
@@ -32,7 +39,12 @@ function getTypedData(
     message: {
       account,
       nonce,
-      ops,
+      op: element.mandate.destinationOps,
+      // todo
+      gasRefund: {
+        token: zeroAddress,
+        exchangeRate: 0n,
+      },
     },
   }
 }

src/execution/utils.ts

@@ -702,11 +702,7 @@ async function prepareTransactionAsIntent(
     })),
     recipient,
     account: intentAccount,
-    destinationExecutions: calls.map((call) => ({
-      to: call.to,
-      value: call.value.toString(),
-      data: call.data,
-    })),
+    destinationExecutions: calls,
     destinationGasUnits: gasLimit,
     accountAccessList,
     options: {

src/orchestrator/types.ts

@@ -63,7 +63,7 @@ interface Claim {
 
 interface Execution {
   to: Address
-  value: string
+  value: bigint
   data: Hex
 }
 
@@ -146,13 +146,18 @@ interface IntentCost {
   }
 }
 
+export interface Op {
+  vt: Hex
+  ops: Execution[]
+}
+
 interface IntentOpElementMandate {
   recipient: Address
   tokenOut: [[string, string]]
   destinationChainId: string
   fillDeadline: string
-  destinationOps: Execution[]
-  preClaimOps: Execution[]
+  destinationOps: Op
+  preClaimOps: Op
   qualifier: {
     settlementContext: {
       settlementLayer: SettlementLayer
@@ -162,7 +167,6 @@ interface IntentOpElementMandate {
     }
     encodedVal: Hex
   }
-  v: number
   minGas: string
 }
 

test/orchestrator.ts

@@ -1,3 +1,4 @@
+import { zeroHash } from 'viem'
 import { vi } from 'vitest'
 
 export function createOrchestratorMock() {
@@ -52,16 +53,18 @@ export function createOrchestratorMock() {
               ],
               destinationChainId: '8453',
               fillDeadline: '1751908044',
-              destinationOps: [
-                {
-                  to: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
-                  value: '3',
-                  data: '0x',
-                },
-              ],
-              v: 27,
+              destinationOps: {
+                vt: '0x0203000000000000000000000000000000000000000000000000000000000000',
+                ops: [
+                  {
+                    to: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+                    value: '3',
+                    data: '0x',
+                  },
+                ],
+              },
               minGas: 1000000000000000000n,
-              preClaimOps: [],
+              preClaimOps: { vt: zeroHash, ops: [] },
               qualifier: {
                 settlementContext: {
                   settlementLayer: 'SAME_CHAIN',