@crediolabs/policy-synth 0.1.6 → 0.1.8

package/dist/run/schemas.js

@@ -36,6 +36,13 @@ export const ScValSchema = z.lazy(() => z.union([
     z.object({ type: z.literal('u32'), value: z.string().regex(/^[0-9]+$/) }),
     z.object({ type: z.literal('symbol'), value: z.string() }),
     z.object({ type: z.literal('vec'), value: z.array(ScValSchema) }),
+    // Map mirrors the core ScVal. Real Blend `submit` calls carry a vec of maps
+    // as the request argument, so omitting it here made the synthesizer reject a
+    // recording its own recorder had just produced at full confidence.
+    z.object({
+        type: z.literal('map'),
+        value: z.array(z.object({ key: z.string(), val: ScValSchema })),
+    }),
     z.object({ type: z.literal('bytes'), value: z.string() }),
     z.object({ type: z.literal('other'), value: z.string() }),
 ]));

package/dist/synth/compose-from-recording.js

@@ -250,6 +250,32 @@ function appendProtocolSpecificConstraints(ozConstraints, interpreterConstraints
             }
         }
     }
+    // Blend submit / claim: the `to` arg is the beneficiary - it receives the
+    // resulting position shares on `submit` and the claimed tokens on `claim`.
+    // That is the same role as the SEP-41 recipient above and the SoroSwap swap
+    // recipient below, so it is pinned to the recorded address the same way:
+    // without it a policy scoped to a pool and method still lets an agent send
+    // the proceeds anywhere. `from` and `spender` are deliberately NOT pinned -
+    // the call already requires their authorisation, so binding them adds no
+    // restriction the chain is not already enforcing.
+    if (protocol.protocol === 'blend' && (protocol.fn === 'submit' || protocol.fn === 'claim')) {
+        // Index 2 in both signatures: submit(from, spender, to, requests) and
+        // claim(from, reserve_token_ids, to).
+        const toArg = topLevel.args[2];
+        if (toArg && toArg.type === 'address') {
+            const cond = {
+                op: 'in',
+                selector: { kind: 'arg', argIndex: 2, scalarType: 'address' },
+                values: [toArg.value],
+            };
+            if (interpreterEnabled) {
+                interpreterConstraints.push(cond);
+            }
+            else {
+                ozConstraints.push(cond);
+            }
+        }
+    }
     // SoroSwap: the recorded hop path -> eq_seq on the path arg (call_arg[2]).
     // The interpreter adapter is the ONLY way to express an exact ordered
     // sequence (OZ built-ins cannot). Element order is preserved verbatim.

package/dist-cjs/run/schemas.js

@@ -39,6 +39,13 @@ exports.ScValSchema = zod_1.z.lazy(() => zod_1.z.union([
     zod_1.z.object({ type: zod_1.z.literal('u32'), value: zod_1.z.string().regex(/^[0-9]+$/) }),
     zod_1.z.object({ type: zod_1.z.literal('symbol'), value: zod_1.z.string() }),
     zod_1.z.object({ type: zod_1.z.literal('vec'), value: zod_1.z.array(exports.ScValSchema) }),
+    // Map mirrors the core ScVal. Real Blend `submit` calls carry a vec of maps
+    // as the request argument, so omitting it here made the synthesizer reject a
+    // recording its own recorder had just produced at full confidence.
+    zod_1.z.object({
+        type: zod_1.z.literal('map'),
+        value: zod_1.z.array(zod_1.z.object({ key: zod_1.z.string(), val: exports.ScValSchema })),
+    }),
     zod_1.z.object({ type: zod_1.z.literal('bytes'), value: zod_1.z.string() }),
     zod_1.z.object({ type: zod_1.z.literal('other'), value: zod_1.z.string() }),
 ]));

package/dist-cjs/synth/compose-from-recording.js

@@ -253,6 +253,32 @@ function appendProtocolSpecificConstraints(ozConstraints, interpreterConstraints
             }
         }
     }
+    // Blend submit / claim: the `to` arg is the beneficiary - it receives the
+    // resulting position shares on `submit` and the claimed tokens on `claim`.
+    // That is the same role as the SEP-41 recipient above and the SoroSwap swap
+    // recipient below, so it is pinned to the recorded address the same way:
+    // without it a policy scoped to a pool and method still lets an agent send
+    // the proceeds anywhere. `from` and `spender` are deliberately NOT pinned -
+    // the call already requires their authorisation, so binding them adds no
+    // restriction the chain is not already enforcing.
+    if (protocol.protocol === 'blend' && (protocol.fn === 'submit' || protocol.fn === 'claim')) {
+        // Index 2 in both signatures: submit(from, spender, to, requests) and
+        // claim(from, reserve_token_ids, to).
+        const toArg = topLevel.args[2];
+        if (toArg && toArg.type === 'address') {
+            const cond = {
+                op: 'in',
+                selector: { kind: 'arg', argIndex: 2, scalarType: 'address' },
+                values: [toArg.value],
+            };
+            if (interpreterEnabled) {
+                interpreterConstraints.push(cond);
+            }
+            else {
+                ozConstraints.push(cond);
+            }
+        }
+    }
     // SoroSwap: the recorded hop path -> eq_seq on the path arg (call_arg[2]).
     // The interpreter adapter is the ONLY way to express an exact ordered
     // sequence (OZ built-ins cannot). Element order is preserved verbatim.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crediolabs/policy-synth",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "license": "MIT",
   "description": "Off-chain TypeScript synthesis core for the OZ Accounts Policy Builder. Records Soroban transactions, synthesises the minimal policy that permits exactly that flow, verifies it, and returns an unsigned install transaction.",
   "type": "module",

package/src/run/schemas.ts

@@ -42,6 +42,13 @@ export const ScValSchema: z.ZodType<unknown> = z.lazy(() =>
     z.object({ type: z.literal('u32'), value: z.string().regex(/^[0-9]+$/) }),
     z.object({ type: z.literal('symbol'), value: z.string() }),
     z.object({ type: z.literal('vec'), value: z.array(ScValSchema) }),
+    // Map mirrors the core ScVal. Real Blend `submit` calls carry a vec of maps
+    // as the request argument, so omitting it here made the synthesizer reject a
+    // recording its own recorder had just produced at full confidence.
+    z.object({
+      type: z.literal('map'),
+      value: z.array(z.object({ key: z.string(), val: ScValSchema })),
+    }),
     z.object({ type: z.literal('bytes'), value: z.string() }),
     z.object({ type: z.literal('other'), value: z.string() }),
   ])

package/src/synth/compose-from-recording.ts

@@ -355,6 +355,32 @@ function appendProtocolSpecificConstraints(
     }
   }
 
+  // Blend submit / claim: the `to` arg is the beneficiary - it receives the
+  // resulting position shares on `submit` and the claimed tokens on `claim`.
+  // That is the same role as the SEP-41 recipient above and the SoroSwap swap
+  // recipient below, so it is pinned to the recorded address the same way:
+  // without it a policy scoped to a pool and method still lets an agent send
+  // the proceeds anywhere. `from` and `spender` are deliberately NOT pinned -
+  // the call already requires their authorisation, so binding them adds no
+  // restriction the chain is not already enforcing.
+  if (protocol.protocol === 'blend' && (protocol.fn === 'submit' || protocol.fn === 'claim')) {
+    // Index 2 in both signatures: submit(from, spender, to, requests) and
+    // claim(from, reserve_token_ids, to).
+    const toArg = topLevel.args[2]
+    if (toArg && toArg.type === 'address') {
+      const cond: IRCondition = {
+        op: 'in',
+        selector: { kind: 'arg', argIndex: 2, scalarType: 'address' },
+        values: [toArg.value],
+      }
+      if (interpreterEnabled) {
+        interpreterConstraints.push(cond)
+      } else {
+        ozConstraints.push(cond)
+      }
+    }
+  }
+
   // SoroSwap: the recorded hop path -> eq_seq on the path arg (call_arg[2]).
   // The interpreter adapter is the ONLY way to express an exact ordered
   // sequence (OZ built-ins cannot). Element order is preserved verbatim.