@crediolabs/policy-synth 0.4.0 → 0.5.1

package/dist-cjs/synth/declare.js

@@ -16,11 +16,12 @@
 // first: it constrains the amount in THIS call rather than implying a rolling
 // total nothing tracks.
 //
-// What a declaration can say maps one-to-one onto grammar 3:
-//   fn         -> eq(call_fn, literal_symbol)
-//   contract   -> eq(call_contract, literal_address)
-//   maxAmount  -> lte(call_arg(i), literal_i128)
-//   recipients -> in(call_arg(j), [literal_address, ...])
+// What a declaration can say maps one-to-one onto grammar 4:
+//   fn            -> eq(call_fn, literal_symbol)
+//   contract      -> eq(call_contract, literal_address)
+//   maxAmount     -> lte(call_arg(i), literal_i128)
+//   recipients    -> in(call_arg(j), [literal_address, ...])
+//   minOutputRatio-> gte(call_arg(out), call_arg_scaled(in, num, den))
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.declarePredicate = declarePredicate;
 const address_ts_1 = require("./address.js");
@@ -87,6 +88,34 @@ function declarePredicate(d) {
             right: { kind: 'literal_i128', value: d.maxAmount },
         });
     }
+    if (d.minOutputRatio !== undefined) {
+        const { num, den, inputArgIndex, outputArgIndex } = d.minOutputRatio;
+        if (!/^[0-9]+$/.test(num) || !/^[0-9]+$/.test(den)) {
+            throw declareError('SYNTHESIS_ERROR', `minOutputRatio num/den must be unsigned integers, got "${num}"/"${den}" (a 1% slippage tolerance is num "99", den "100")`);
+        }
+        // Both are refused on chain at install (INVALID_SCALED_RATIO). Refusing
+        // here too means the caller learns before a transaction is built.
+        if (den === '0') {
+            throw declareError('SYNTHESIS_ERROR', 'minOutputRatio.den is zero: the ratio has no value');
+        }
+        if (num === '0') {
+            throw declareError('SYNTHESIS_ERROR', 'minOutputRatio.num is zero: the floor would be zero, which constrains nothing. Omit it instead.');
+        }
+        if (inputArgIndex === outputArgIndex) {
+            throw declareError('SYNTHESIS_ERROR', `minOutputRatio bounds arg[${inputArgIndex}] against itself, which is true for any ratio at or below 1 and false above it - never a slippage floor. Pass the distinct input and output positions.`);
+        }
+        if (BigInt(num) > BigInt(den)) {
+            // Demanding MORE out than went in is not slippage protection; it is a
+            // rule that denies every honest trade. Loud beats a policy that never
+            // permits.
+            warnings.push(`minOutputRatio ${num}/${den} is above 1: it requires the output to EXCEED the input, which no ordinary swap satisfies. Check the ratio is not inverted.`);
+        }
+        children.push({
+            op: 'gte',
+            left: { kind: 'call_arg', index: outputArgIndex },
+            right: { kind: 'call_arg_scaled', index: inputArgIndex, num, den },
+        });
+    }
     // A single conjunct is emitted bare. `and` with one child encodes to
     // different bytes than the child alone, and the extra node buys nothing.
     const predicate = children.length === 1 ? children[0] : { op: 'and', children };

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

@@ -2,7 +2,7 @@
 // src/synth/synthesize-from-recording.ts - recording-path orchestrator.
 //
 // `synthesizeFromRecording` INFERS a bounded policy from a `RecordedTransaction`
-// via the `PolicyIR` + interpreter adapter pair.
+// via the composer + interpreter adapter pair.
 // Flow: validate -> parseConfidence gate -> lower -> decideScope -> composeFromRecording
 // -> interpreter compile + self-verify.
 // Same (tx, opts) -> byte-identical ProposedPolicy (no randomness, clock, globals).

package/dist-cjs/types.d.ts

@@ -124,7 +124,7 @@ export type PolicyRef = {
  *  `contracts/policy-interpreter/src/version.rs`. Every value this package puts on
  *  the wire derives from here; `grammar-version-parity.test.ts` pins it to the
  *  contract so a skew cannot pass a green test run. */
-export declare const GRAMMAR_VERSION: 3;
+export declare const GRAMMAR_VERSION: 4;
 /** A serialised predicate document stored against a (smart_account, rule_id) pair. */
 export interface PolicyDocument {
     /** Grammar version baked into the interpreter wasm. Fail-closed strict match at install
@@ -146,14 +146,29 @@ export interface PolicyDocument {
 export type PredicateNode = {
     op: 'and';
     children: PredicateNode[];
+} | {
+    op: 'or';
+    children: PredicateNode[];
 } | {
     op: 'eq';
     left: PredicateLeaf;
     right: PredicateLeaf;
+} | {
+    op: 'lt';
+    left: PredicateLeaf;
+    right: PredicateLeaf;
 } | {
     op: 'lte';
     left: PredicateLeaf;
     right: PredicateLeaf;
+} | {
+    op: 'gt';
+    left: PredicateLeaf;
+    right: PredicateLeaf;
+} | {
+    op: 'gte';
+    left: PredicateLeaf;
+    right: PredicateLeaf;
 } | {
     op: 'in';
     needle: PredicateLeaf;
@@ -174,6 +189,11 @@ export type PredicateLeaf = {
     index: number;
     element: number;
     field: string;
+} | {
+    kind: 'call_arg_scaled';
+    index: number;
+    num: string;
+    den: string;
 } | {
     kind: 'literal_address';
     value: string;

package/dist-cjs/types.js

@@ -55,4 +55,4 @@ exports.PREDICATE_CAPS = {
  *  `contracts/policy-interpreter/src/version.rs`. Every value this package puts on
  *  the wire derives from here; `grammar-version-parity.test.ts` pins it to the
  *  contract so a skew cannot pass a green test run. */
-exports.GRAMMAR_VERSION = 3;
+exports.GRAMMAR_VERSION = 4;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@crediolabs/policy-synth",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "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/adapters/interpreter/adapter.ts

@@ -1,6 +1,6 @@
-// src/adapters/interpreter/adapter.ts - the interpreter-policy CustodyAdapter.
+// src/adapters/interpreter/adapter.ts - the interpreter-policy adapter.
 //
-// Compiles a PolicyIR to a single interpreter `PolicyDocument` + `PolicyRef`
+// Compiles a `ComposedRule` to a single interpreter `PolicyDocument` + `PolicyRef`
 // carrying the canonical predicate encoding from `predicate/encode.ts`. This is
 // the only backend; the compose step lowers every constraint to it.
 //
@@ -41,9 +41,9 @@ export interface InterpreterAdapterConfig {
   smartAccountAddress: string
 }
 
-/** The result of compiling a PolicyIR for this backend. */
+/** The result of compiling a `ComposedRule` for this backend. */
 export interface CompileResult {
-  /** false => some IR construct this backend cannot express (see `uncovered`). */
+  /** false => some constraint this backend cannot express (see `uncovered`). */
   covered: boolean
   /** Human-readable list of unsupported constructs. */
   uncovered: string[]
@@ -195,14 +195,22 @@ function assertNoSelfCall(node: PredicateNode, config: InterpreterAdapterConfig)
     }
   }
   switch (node.op) {
+    // Both boolean nodes recurse. `or` is listed explicitly rather than left
+    // to a default branch: this is a security check, and a new node kind must
+    // fail to compile here rather than silently skip it.
     case 'and':
+    case 'or':
       for (const c of node.children) assertNoSelfCall(c, config)
       return
     case 'in':
       // The needle is a selector; only the haystack carries literals.
       for (const h of node.haystack) checkLeaf(h)
       return
-    default:
+    case 'eq':
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte':
       checkLeaf(node.left)
       checkLeaf(node.right)
   }

package/src/errors.ts

@@ -43,6 +43,11 @@ export type ErrorCode =
   | 'UNSUPPORTED_NODE'
   | 'STATEFUL_BOUND'
   | 'NOT_IN_ALLOWLIST'
+  /** A comparison against a `call_arg_scaled` operand failed (contract 107). */
+  | 'SLIPPAGE_FLOOR'
+  /** A `call_arg_scaled` ratio is zero or non-positive. Refused at install
+   *  (contract 214) and mirrored at encode. */
+  | 'INVALID_SCALED_RATIO'
   // --- escape-hatch compile gate ---
   | 'COMPILE_OK'
   | 'COMPILE_GATE_FAILED'

package/src/install/authority-overlap.ts

@@ -200,6 +200,17 @@ export function permittedSelectors(node: PredicateNode): Selector[] {
       for (const child of node.children) acc = intersectSelectors(acc, permittedSelectors(child))
       return acc
     }
+    case 'or': {
+      // Any branch may hold, so the permitted set is the UNION. A union of
+      // over-approximations is still an over-approximation, so this keeps the
+      // fail-safe direction while staying tighter than the wildcard the
+      // default branch would give. Precision matters here: `or` is how a
+      // policy says "pair A or pair B", and widening that to the wildcard
+      // would report an overlap against every rule on the account.
+      const acc: Selector[] = []
+      for (const child of node.children) acc.push(...permittedSelectors(child))
+      return dedupe(acc)
+    }
     case 'eq': {
       const sel = selectorFromEq(node.left, node.right)
       return sel === null ? [WILDCARD] : [sel]

package/src/install/read-account-rules.ts

@@ -0,0 +1,313 @@
+//! Reading an OpenZeppelin smart account's context rules back off chain.
+//!
+//! `authority-overlap.ts` needs to know what a signer can already do before a
+//! new policy is installed. That means every rule on the account: its context
+//! type, its signers, its attached policies, and - for rules our interpreter
+//! polices - the predicate itself.
+//!
+//! Without this, the overlap scan can only report on rules the CALLER supplied,
+//! which means it answers "what did you tell me about" rather than "what is on
+//! the account". Those are different questions, and only the second one is
+//! worth anything to someone deciding whether to sign.
+//!
+//! The predicate is NOT reachable through a contract call. The interpreter
+//! publishes only `grammar_version`, `install`, `enforce`, `uninstall` and
+//! `rotate_master_signer_set`, so the stored document is read as a ledger entry
+//! instead. That keeps this a purely client-side capability: adding a getter
+//! would change a deployed contract's ABI and force a redeploy plus re-audit to
+//! obtain data the ledger already exposes.
+//!
+//! The decoders are pure so they can be tested without a network; the caller
+//! supplies raw `ScVal`s.
+
+import {
+  Account,
+  Address,
+  BASE_FEE,
+  Contract,
+  Keypair,
+  rpc,
+  TransactionBuilder,
+  xdr,
+} from '@stellar/stellar-sdk'
+import { decodePredicate } from '../predicate/decode.ts'
+import type { SignerDraft } from '../types.ts'
+import type { ContextType, ObservedRule } from './authority-overlap.ts'
+
+/** `storage.rs` - the third element of the persistent doc key tuple. */
+export const K_DOC = 1
+
+/** Persistent-storage key for a rule's stored document:
+ *  `(account, rule_id, K_DOC)`. */
+export function docKeyScVal(smartAccount: string, ruleId: number): xdr.ScVal {
+  return xdr.ScVal.scvVec([
+    new Address(smartAccount).toScVal(),
+    xdr.ScVal.scvU32(ruleId),
+    xdr.ScVal.scvU32(K_DOC),
+  ])
+}
+
+/** Ledger key for the interpreter's persistent entry holding that document. */
+export function docLedgerKey(
+  interpreter: string,
+  smartAccount: string,
+  ruleId: number
+): xdr.LedgerKey {
+  return xdr.LedgerKey.contractData(
+    new xdr.LedgerKeyContractData({
+      contract: new Address(interpreter).toScAddress(),
+      key: docKeyScVal(smartAccount, ruleId),
+      durability: xdr.ContractDataDurability.persistent(),
+    })
+  )
+}
+
+// ---- ScVal helpers -----
+
+/** Field of a `#[contracttype]` struct, which the host encodes as a map keyed
+ *  by field-name symbol. Returns undefined when the field is absent so a
+ *  caller can distinguish "not there" from "there and empty". */
+function mapField(v: xdr.ScVal, name: string): xdr.ScVal | undefined {
+  if (v.switch() !== xdr.ScValType.scvMap()) return undefined
+  for (const entry of v.map() ?? []) {
+    const key = entry.key()
+    if (key.switch() === xdr.ScValType.scvSymbol() && key.sym().toString() === name) {
+      return entry.val()
+    }
+  }
+  return undefined
+}
+
+function u32Of(v: xdr.ScVal | undefined): number | undefined {
+  return v?.switch() === xdr.ScValType.scvU32() ? v.u32() : undefined
+}
+
+function addressOf(v: xdr.ScVal | undefined): string | undefined {
+  if (!v || v.switch() !== xdr.ScValType.scvAddress()) return undefined
+  return Address.fromScAddress(v.address()).toString()
+}
+
+/** An enum variant of a `#[contracttype]` enum: `ScVal::Vec([Symbol, ...args])`. */
+function enumVariant(v: xdr.ScVal | undefined): { tag: string; args: xdr.ScVal[] } | undefined {
+  if (!v || v.switch() !== xdr.ScValType.scvVec()) return undefined
+  const items = v.vec() ?? []
+  const head = items[0]
+  if (!head || head.switch() !== xdr.ScValType.scvSymbol()) return undefined
+  return { tag: head.sym().toString(), args: items.slice(1) }
+}
+
+// ---- decoders -----
+
+/** OZ `ContextRuleType`. An unrecognised tag is reported as `default`, which
+ *  is the widest reading and therefore the safe one: it makes the rule look
+ *  like it could serve any call, so overlap is over-reported, never missed. */
+export function decodeContextType(v: xdr.ScVal | undefined): ContextType {
+  const variant = enumVariant(v)
+  if (!variant) return { kind: 'default' }
+  if (variant.tag === 'CallContract') {
+    const addr = addressOf(variant.args[0])
+    return addr ? { kind: 'call_contract', contract: addr } : { kind: 'default' }
+  }
+  if (variant.tag === 'CreateContract') {
+    const arg = variant.args[0]
+    const hash = arg?.switch() === xdr.ScValType.scvBytes() ? arg.bytes().toString('hex') : ''
+    return { kind: 'create_contract', wasmHash: hash }
+  }
+  return { kind: 'default' }
+}
+
+/** OZ `Signer::Delegated(Address) | Signer::External(Address, Bytes)`. */
+export function decodeSigner(v: xdr.ScVal): SignerDraft | undefined {
+  const variant = enumVariant(v)
+  if (!variant) return undefined
+  if (variant.tag === 'Delegated') {
+    const addr = addressOf(variant.args[0])
+    return addr ? { kind: 'delegated', address: addr } : undefined
+  }
+  if (variant.tag === 'External') {
+    const verifier = addressOf(variant.args[0])
+    const keyArg = variant.args[1]
+    const keyBytes =
+      keyArg?.switch() === xdr.ScValType.scvBytes() ? keyArg.bytes().toString('hex') : ''
+    return verifier ? { kind: 'external', verifier, keyBytes } : undefined
+  }
+  return undefined
+}
+
+/** A full OZ `ContextRule` as returned by `get_context_rule(id)`.
+ *  `predicate` is filled in separately from the ledger entry. */
+export function decodeContextRule(v: xdr.ScVal): ObservedRule | undefined {
+  const id = u32Of(mapField(v, 'id'))
+  if (id === undefined) return undefined
+
+  const signersVal = mapField(v, 'signers')
+  const signers: SignerDraft[] = []
+  if (signersVal?.switch() === xdr.ScValType.scvVec()) {
+    for (const s of signersVal.vec() ?? []) {
+      const decoded = decodeSigner(s)
+      if (decoded) signers.push(decoded)
+    }
+  }
+
+  const policiesVal = mapField(v, 'policies')
+  const policyAddresses: string[] = []
+  if (policiesVal?.switch() === xdr.ScValType.scvVec()) {
+    for (const p of policiesVal.vec() ?? []) {
+      const addr = addressOf(p)
+      if (addr) policyAddresses.push(addr)
+    }
+  }
+
+  return {
+    id,
+    contextType: decodeContextType(mapField(v, 'context_type')),
+    signers,
+    policyAddresses,
+  }
+}
+
+/** The interpreter's `StoredDoc { predicate_bytes }`. */
+export function decodeStoredPredicateBytes(v: xdr.ScVal): Buffer | undefined {
+  const field = mapField(v, 'predicate_bytes')
+  if (!field || field.switch() !== xdr.ScValType.scvBytes()) return undefined
+  return field.bytes()
+}
+
+// ---- collection -----
+
+/** The three reads the scan needs. Kept as an interface so the collection
+ *  below is testable without a network. */
+export interface AccountRuleReader {
+  /** OZ `get_context_rules_count()`. */
+  getContextRuleCount(smartAccount: string): Promise<number>
+  /** OZ `get_context_rule(id)`. Undefined when the id is absent. */
+  getContextRule(smartAccount: string, ruleId: number): Promise<xdr.ScVal | undefined>
+  /** The interpreter's persistent `StoredDoc` entry, read as a ledger entry.
+   *  Undefined when no document is stored for that rule. */
+  getStoredDoc(
+    interpreter: string,
+    smartAccount: string,
+    ruleId: number
+  ): Promise<xdr.ScVal | undefined>
+}
+
+/** How far the id scan will probe before giving up. OZ imposes no per-account
+ *  rule cap, so there is no exact bound to derive; this one is far above any
+ *  realistic account and keeps a malformed `Count` from spinning forever. */
+export const MAX_RULE_ID_SCAN = 512
+
+export interface CollectedRules {
+  rules: ObservedRule[]
+  /** Rule ids whose stored predicate could not be read even though the
+   *  interpreter is attached. Such a rule is reported without a predicate,
+   *  which classifies it as opaque rather than as safely narrow. */
+  unreadablePredicateRuleIds: number[]
+  /** True when the scan stopped before accounting for every live rule. The
+   *  result is then a SUBSET of the account's rules, so an empty overlap list
+   *  proves nothing and the caller must not present it as safety. */
+  incomplete: boolean
+}
+
+/**
+ * Every context rule on the account, with predicates filled in for the rules
+ * our interpreter polices.
+ *
+ * Rule ids are NOT contiguous. OZ assigns them from a monotonic `NextId` and
+ * decrements `Count` on removal without ever reusing an id, so after any
+ * removal `Count < NextId` and the live ids have gaps. Iterating `0..Count-1`
+ * would silently skip live rules at higher ids, and a skipped rule is a missed
+ * overlap - the one error that reports safety which does not exist. Instead the
+ * scan walks ids upward until it has accounted for `Count` live rules.
+ *
+ * A rule whose predicate cannot be read is deliberately left without one. That
+ * demotes it to the `foreign` class, so the scan reports it as opaque instead
+ * of assuming it is narrow.
+ */
+export async function collectObservedRules(args: {
+  reader: AccountRuleReader
+  smartAccount: string
+  interpreterAddress: string
+  maxRuleIdScan?: number
+}): Promise<CollectedRules> {
+  const count = await args.reader.getContextRuleCount(args.smartAccount)
+  const limit = args.maxRuleIdScan ?? MAX_RULE_ID_SCAN
+  const rules: ObservedRule[] = []
+  const unreadablePredicateRuleIds: number[] = []
+
+  let id = 0
+  while (rules.length < count && id < limit) {
+    const raw = await args.reader.getContextRule(args.smartAccount, id)
+    id++
+    if (!raw) continue
+    const rule = decodeContextRule(raw)
+    if (!rule) continue
+
+    if (rule.policyAddresses.includes(args.interpreterAddress)) {
+      const doc = await args.reader.getStoredDoc(
+        args.interpreterAddress,
+        args.smartAccount,
+        rule.id
+      )
+      const bytes = doc ? decodeStoredPredicateBytes(doc) : undefined
+      if (bytes) {
+        try {
+          rule.predicate = decodePredicate(bytes)
+        } catch {
+          unreadablePredicateRuleIds.push(rule.id)
+        }
+      } else {
+        unreadablePredicateRuleIds.push(rule.id)
+      }
+    }
+    rules.push(rule)
+  }
+
+  return { rules, unreadablePredicateRuleIds, incomplete: rules.length < count }
+}
+
+/**
+ * An `AccountRuleReader` over a live RPC server.
+ *
+ * The two OZ getters are read-only simulations: the source account is
+ * constructed locally because a simulation never checks its sequence number,
+ * and asking the network for a random key would 404.
+ *
+ * The stored document is fetched as a ledger entry rather than a contract
+ * call, because the interpreter publishes no getter for it.
+ */
+export function accountRuleReaderFromServer(
+  server: rpc.Server,
+  networkPassphrase: string
+): AccountRuleReader {
+  async function simulateCall(
+    contract: string,
+    method: string,
+    ...args: xdr.ScVal[]
+  ): Promise<xdr.ScVal | undefined> {
+    const account = new Account(Keypair.random().publicKey(), '0')
+    const tx = new TransactionBuilder(account, { fee: BASE_FEE, networkPassphrase })
+      .addOperation(new Contract(contract).call(method, ...args))
+      .setTimeout(30)
+      .build()
+    const sim = await server.simulateTransaction(tx)
+    if (rpc.Api.isSimulationError(sim)) return undefined
+    return sim.result?.retval
+  }
+
+  return {
+    async getContextRuleCount(smartAccount) {
+      const val = await simulateCall(smartAccount, 'get_context_rules_count')
+      return u32Of(val) ?? 0
+    },
+    async getContextRule(smartAccount, ruleId) {
+      return simulateCall(smartAccount, 'get_context_rule', xdr.ScVal.scvU32(ruleId))
+    },
+    async getStoredDoc(interpreter, smartAccount, ruleId) {
+      const key = docLedgerKey(interpreter, smartAccount, ruleId)
+      const res = await server.getLedgerEntries(key)
+      const entry = res.entries?.[0]?.val
+      if (!entry || entry.switch() !== xdr.LedgerEntryType.contractData()) return undefined
+      return entry.contractData().val()
+    },
+  }
+}

package/src/predicate/decode.ts

@@ -64,6 +64,15 @@ function expectSymbol(v: xdr.ScVal | undefined, what: string): string {
   return v.sym().toString()
 }
 
+/** Strict i128, returned as a decimal string. Strict on purpose: the Rust
+ *  decoder refuses a u32 in an i128 slot rather than widening it, so
+ *  accepting one here would let a predicate decode off chain and be refused
+ *  on chain. */
+function expectI128(v: xdr.ScVal | undefined, what: string): string {
+  if (!v || v.switch() !== xdr.ScValType.scvI128()) throw malformed(`${what} is not an i128`)
+  return scValToBigInt(v).toString()
+}
+
 /** Arity check with the same intent as the Rust `check_arity`: a selector with
  *  the wrong element count is malformed, not silently truncated. */
 function arity(items: xdr.ScVal[], n: number, selector: string): void {
@@ -94,6 +103,14 @@ function decodeSelectorLeaf(items: xdr.ScVal[], sym: string): PredicateLeaf {
         element: expectU32(items[2], 'call_arg_field element'),
         field: expectSymbol(items[3], 'call_arg_field field'),
       }
+    case 'call_arg_scaled':
+      arity(items, 4, sym)
+      return {
+        kind: 'call_arg_scaled',
+        index: expectU32(items[1], 'call_arg_scaled index'),
+        num: expectI128(items[2], 'call_arg_scaled num'),
+        den: expectI128(items[3], 'call_arg_scaled den'),
+      }
     default:
       // Deliberately NOT a literal_vec fallback - see the header note.
       throw malformed(`unknown selector symbol '${sym}'`)
@@ -129,14 +146,18 @@ export function decodeNode(v: xdr.ScVal): PredicateNode {
   const op = selectorSymbol(items)
   if (op === null) throw malformed('node does not start with an operator symbol')
   switch (op) {
-    case 'and': {
+    case 'and':
+    case 'or': {
       arity(items, 2, op)
       const children = expectVec(items[1] as xdr.ScVal, `${op} children`).map(decodeNode)
       if (children.length === 0) throw malformed(`${op} has no children`)
       return { op, children }
     }
     case 'eq':
+    case 'lt':
     case 'lte':
+    case 'gt':
+    case 'gte':
       arity(items, 3, op)
       return {
         op,

package/src/predicate/encode.ts

@@ -124,7 +124,8 @@ function walk(
   counters: { selectorLeaves: number }
 ): { depth: number; leaves: number } {
   switch (node.op) {
-    case 'and': {
+    case 'and':
+    case 'or': {
       if (node.children.length === 0) {
         throw capError(
           'MALFORMED_PREDICATE',
@@ -141,7 +142,10 @@ function walk(
       return { depth: maxChildDepth + 1, leaves: totalLeaves }
     }
     case 'eq':
-    case 'lte': {
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte': {
       collectSelector(node.left, counters)
       collectSelector(node.right, counters)
       return { depth: 1, leaves: leafCount(node.left) + leafCount(node.right) }
@@ -192,14 +196,20 @@ function collectSelector(leaf: PredicateLeaf, counters: { selectorLeaves: number
 
 function encodeNode(node: PredicateNode): xdr.ScVal {
   switch (node.op) {
-    case 'and': {
+    case 'and':
+    case 'or': {
       const encoded = node.children.map(encodeNode)
-      // sort children by their canonical XDR bytes ascending.
+      // sort children by their canonical XDR bytes ascending. Both operators
+      // are commutative for the permit decision, so sorting costs no meaning
+      // and buys a stable hash for logically-identical predicates.
       const sorted = sortByCanonicalBytes(encoded)
       return xdr.ScVal.scvVec([symbol(node.op), xdr.ScVal.scvVec(sorted)])
     }
     case 'eq':
-    case 'lte': {
+    case 'lt':
+    case 'lte':
+    case 'gt':
+    case 'gte': {
       return xdr.ScVal.scvVec([symbol(node.op), encodeLeaf(node.left), encodeLeaf(node.right)])
     }
     case 'in': {
@@ -231,6 +241,15 @@ function encodeLeaf(leaf: PredicateLeaf): xdr.ScVal {
         xdr.ScVal.scvU32(leaf.element),
         xdr.ScVal.scvSymbol(leaf.field),
       ])
+    case 'call_arg_scaled':
+      // num/den are i128 on the wire. The Rust decoder type-checks both
+      // slots, so a u32 here would be refused rather than widened.
+      return xdr.ScVal.scvVec([
+        symbol('call_arg_scaled'),
+        xdr.ScVal.scvU32(leaf.index),
+        scvI128FromDecimal(leaf.num),
+        scvI128FromDecimal(leaf.den),
+      ])
     case 'literal_address':
       return scvAddressFromStrkey(leaf.value)
     case 'literal_i128':
@@ -332,6 +351,33 @@ function validateLeafValues(node: PredicateNode): void {
           throw malformed(`call_arg_field.element out of u32 range at ${path}`)
         }
         return
+      case 'call_arg_scaled': {
+        if (!Number.isInteger(leaf.index) || leaf.index < 0 || leaf.index > U32_MAX) {
+          throw malformed(`call_arg_scaled.index out of u32 range at ${path}`)
+        }
+        // Mirror of the contract's install gate (214). Without it the TS
+        // self-verify would green-light a ratio the chain refuses, which is
+        // exactly the divergence this validator exists to prevent.
+        let num: bigint
+        let den: bigint
+        try {
+          num = BigInt(leaf.num)
+          den = BigInt(leaf.den)
+        } catch {
+          throw malformed(`call_arg_scaled num/den must be i128 decimal strings at ${path}`)
+        }
+        if (den === 0n) {
+          throw malformed(
+            `call_arg_scaled.den is zero at ${path}: the contract refuses it at install (INVALID_SCALED_RATIO)`
+          )
+        }
+        if (num <= 0n || den < 0n) {
+          throw malformed(
+            `call_arg_scaled ratio ${leaf.num}/${leaf.den} at ${path} is not positive: a negative ratio inverts the comparison, so the floor would permit what it was written to refuse. The contract refuses it at install (INVALID_SCALED_RATIO)`
+          )
+        }
+        return
+      }
       case 'call_contract':
       case 'call_fn':
       case 'literal_address':
@@ -342,12 +388,16 @@ function validateLeafValues(node: PredicateNode): void {
   function walkNode(n: PredicateNode, path: string): void {
     switch (n.op) {
       case 'and':
+      case 'or':
         n.children.forEach((c, i) => {
           walkNode(c, `${path}.children[${i}]`)
         })
         return
       case 'eq':
+      case 'lt':
       case 'lte':
+      case 'gt':
+      case 'gte':
         walkLeaf(n.left, `${path}.left`)
         walkLeaf(n.right, `${path}.right`)
         return