@crediolabs/policy-synth 0.3.1 → 0.5.0

package/dist-cjs/install/authority-overlap.js

@@ -0,0 +1,248 @@
+"use strict";
+// src/install/authority-overlap.ts - cross-rule authority analysis.
+//
+// An OZ smart account selects a context rule by CALLER DECLARATION and enforces
+// only the policies of the rule that was named. A signer belonging to several
+// rules therefore picks which one applies, so for any given call their
+// authority is the MAXIMUM over the matching rules, never the intersection.
+//
+// The consequence is the one that catches people: installing a second, tighter
+// rule restricts nothing. A key that also sits on an unpoliced rule is not
+// constrained at all - it names that rule and the predicate never runs. This
+// module detects that at install time, before the caller acts on a policy that
+// looks binding and is not.
+//
+// Not theoretical. Proven on chain 2026-08-22: the same key, the same account
+// and the same forbidden call was denied `#100` naming the policed rule and
+// PERMITTED naming an unpoliced one. It happened in this project's own end-to-
+// end harness, written by the author of the grammar, and was caught by review
+// rather than by tooling - which is why the tooling now exists.
+//
+// Adapted to grammar 3 from the version published in `@crediolabs/policy-synth`
+// 0.2.0, which came from the `octogate` repository and was lost when the npm
+// lineage moved here. `or` and `not` are gone from the grammar, so the cases
+// handling them are gone too; oracle bounds are gone from the stored document.
+//
+// Pure: no network. The caller supplies the account's rules.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ANY = void 0;
+exports.signerKey = signerKey;
+exports.intersectSelectors = intersectSelectors;
+exports.permittedSelectors = permittedSelectors;
+exports.selectorsForContextType = selectorsForContextType;
+exports.effectiveSelectors = effectiveSelectors;
+exports.findAuthorityOverlaps = findAuthorityOverlaps;
+/** Wildcard component of a `Selector`: the predicate does not pin this half. */
+exports.ANY = '*';
+// ---- signer identity ----
+/** Canonical key for signer equality. Mirrors OZ's `Signer` enum: a delegated
+ *  signer is its address, an external signer is the verifier plus the key
+ *  bytes, since one verifier may hold many keys. */
+function signerKey(s) {
+    return s.kind === 'delegated' ? `delegated:${s.address}` : `external:${s.verifier}:${s.keyBytes}`;
+}
+function sharedSigners(a, b) {
+    const bKeys = new Set(b.map(signerKey));
+    return a.filter((s) => bKeys.has(signerKey(s)));
+}
+// ---- selector extraction ----
+const WILDCARD = { contract: exports.ANY, fn: exports.ANY };
+function selectorKey(s) {
+    return `${s.contract} ${s.fn}`;
+}
+function dedupe(sels) {
+    const seen = new Map();
+    for (const s of sels)
+        seen.set(selectorKey(s), s);
+    return [...seen.values()];
+}
+/** Intersect one pair. `ANY` absorbs, equal literals survive, and two
+ *  different literals cannot both hold for a single call. */
+function intersectOne(a, b) {
+    const contract = a.contract === exports.ANY
+        ? b.contract
+        : b.contract === exports.ANY
+            ? a.contract
+            : a.contract === b.contract
+                ? a.contract
+                : null;
+    if (contract === null)
+        return null;
+    const fn = a.fn === exports.ANY ? b.fn : b.fn === exports.ANY ? a.fn : a.fn === b.fn ? a.fn : null;
+    if (fn === null)
+        return null;
+    return { contract, fn };
+}
+/** Intersection of two selector SETS: every compatible pairing survives. */
+function intersectSelectors(a, b) {
+    const out = [];
+    for (const x of a) {
+        for (const y of b) {
+            const hit = intersectOne(x, y);
+            if (hit)
+                out.push(hit);
+        }
+    }
+    return dedupe(out);
+}
+function literalAddress(leaf) {
+    return leaf.kind === 'literal_address' ? leaf.value : null;
+}
+function literalSymbol(leaf) {
+    return leaf.kind === 'literal_symbol' ? leaf.value : null;
+}
+/** Selector pinned by a single `eq`, whichever side the literal sits on. */
+function selectorFromEq(left, right) {
+    if (left.kind === 'call_contract') {
+        const addr = literalAddress(right);
+        return addr === null ? null : { contract: addr, fn: exports.ANY };
+    }
+    if (right.kind === 'call_contract') {
+        const addr = literalAddress(left);
+        return addr === null ? null : { contract: addr, fn: exports.ANY };
+    }
+    if (left.kind === 'call_fn') {
+        const sym = literalSymbol(right);
+        return sym === null ? null : { contract: exports.ANY, fn: sym };
+    }
+    if (right.kind === 'call_fn') {
+        const sym = literalSymbol(left);
+        return sym === null ? null : { contract: exports.ANY, fn: sym };
+    }
+    return null;
+}
+/**
+ * The set of `(contract, fn)` selectors a predicate may permit.
+ *
+ * A deliberate OVER-approximation: every call the predicate actually permits is
+ * covered by some returned selector, and unrecognised structure widens to the
+ * wildcard rather than narrowing. That direction is what makes the emptiness
+ * test sound. A call carries exactly one `(contract, fn)`, so if two
+ * predicates' over-approximations do not intersect, no single call can be
+ * routed to either and the rules provably cannot collide.
+ *
+ * Narrowing instead would be the fail-OPEN direction: it would let this report
+ * "no overlap" for rules that do collide.
+ */
+function permittedSelectors(node) {
+    switch (node.op) {
+        case 'and': {
+            // Every conjunct must hold at once, so the permitted set is the
+            // intersection. Intersecting over-approximations stays one.
+            let acc = [WILDCARD];
+            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 = [];
+            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];
+        }
+        case 'in': {
+            // Set membership over the selector halves: `call_fn in {a, b}` permits
+            // both. A haystack element that is not the matching literal kind makes
+            // the node uninformative rather than narrower.
+            if (node.needle.kind === 'call_contract') {
+                const addrs = node.haystack.map(literalAddress);
+                if (addrs.some((a) => a === null))
+                    return [WILDCARD];
+                return dedupe(addrs.map((a) => ({ contract: a, fn: exports.ANY })));
+            }
+            if (node.needle.kind === 'call_fn') {
+                const syms = node.haystack.map(literalSymbol);
+                if (syms.some((s) => s === null))
+                    return [WILDCARD];
+                return dedupe(syms.map((s) => ({ contract: exports.ANY, fn: s })));
+            }
+            return [WILDCARD];
+        }
+        default:
+            // `lte` binds an amount, never the selector.
+            return [WILDCARD];
+    }
+}
+/** Selectors a context type admits, before the predicate narrows them. */
+function selectorsForContextType(ct) {
+    switch (ct.kind) {
+        case 'default':
+            return [WILDCARD];
+        case 'call_contract':
+            return [{ contract: ct.contract, fn: exports.ANY }];
+        case 'create_contract':
+            // A contract-creation context is a different `Context` shape. The
+            // interpreter refuses anything that is not `Context::Contract`, and a
+            // creation rule can never serve a call, so it shares no selector.
+            return [];
+    }
+}
+/** What a rule can actually authorise: its context type narrowed by its
+ *  predicate. An unpoliced or unreadable rule contributes no narrowing. */
+function effectiveSelectors(rule) {
+    const fromType = selectorsForContextType(rule.contextType);
+    if (!rule.predicate)
+        return fromType;
+    return intersectSelectors(fromType, permittedSelectors(rule.predicate));
+}
+function classifyRule(rule) {
+    if (rule.policyAddresses.length === 0)
+        return 'unpoliced';
+    return rule.predicate ? 'interpreter' : 'foreign';
+}
+function adviceFor(cls, ruleId) {
+    switch (cls) {
+        case 'unpoliced':
+            return `rule ${ruleId} has no policy attached, so a shared signer may make these calls with no constraint at all - the predicate you are installing will never run for them. Remove the shared signer from rule ${ruleId}, or attach a policy to it.`;
+        case 'foreign':
+            return `rule ${ruleId} is policed by a contract this tool cannot decode, so its authority over these calls is unknown. Review it by hand before relying on the new rule.`;
+        case 'interpreter':
+            return `a shared signer may name rule ${ruleId} instead, so the new rule will not restrict these calls. To TIGHTEN, edit rule ${ruleId} itself rather than adding a second rule. To ADD a separate capability, keep both and expect neither to constrain the other.`;
+    }
+}
+/**
+ * Every existing rule a signer of the intended install could name instead.
+ *
+ * A rule collides when it shares at least one signer AND at least one selector.
+ * Both are needed for the signer to have a choice: same signer but disjoint
+ * calls means no call can be rerouted, and same calls but no shared signer
+ * means nobody can reroute them.
+ */
+function findAuthorityOverlaps(args) {
+    const intendedSelectors = intersectSelectors(selectorsForContextType(args.intended.contextType), permittedSelectors(args.intended.predicate));
+    const out = [];
+    for (const rule of args.existing) {
+        if (rule.id === args.intended.ruleId)
+            continue;
+        const shared = sharedSigners(args.intended.signers, rule.signers);
+        if (shared.length === 0)
+            continue;
+        const sharedSelectors = intersectSelectors(intendedSelectors, effectiveSelectors(rule));
+        if (sharedSelectors.length === 0)
+            continue;
+        const ruleClass = classifyRule(rule);
+        out.push({
+            ruleId: rule.id,
+            ruleClass,
+            severity: ruleClass === 'unpoliced'
+                ? 'bypass'
+                : ruleClass === 'foreign'
+                    ? 'unknown'
+                    : 'not-restricting',
+            sharedSigners: shared,
+            sharedSelectors,
+            advice: adviceFor(ruleClass, rule.id),
+        });
+    }
+    return out;
+}

package/dist-cjs/install/build-add-context-rule.d.ts

@@ -23,7 +23,7 @@ export interface BuildAddContextRuleArgs {
      *  before the chain does; the contract will refuse a mismatch again. */
     grammarVersion?: number;
 }
-export declare const DEFAULT_GRAMMAR_VERSION: 3;
+export declare const DEFAULT_GRAMMAR_VERSION: 4;
 /** The verb `add_context_rule` takes on the wire. */
 export declare const ADD_CONTEXT_RULE_SYMBOL: "add_context_rule";
 /** Tuple of `ScVal` arguments to pass to `Operation.invokeHostFunction` for

package/dist-cjs/install/index.d.ts

@@ -1 +1,2 @@
+export { ANY, type AuthorityOverlap, type ContextType, effectiveSelectors, findAuthorityOverlaps, type IntendedInstall, intersectSelectors, type ObservedRule, type OverlapSeverity, permittedSelectors, type RuleClass, type Selector, selectorsForContextType, signerKey, } from './authority-overlap.ts';
 export { ADD_CONTEXT_RULE_SYMBOL, type AddContextRuleArgs, type BuildAddContextRuleArgs, buildAddContextRuleArgs, DEFAULT_GRAMMAR_VERSION, } from './build-add-context-rule.ts';

package/dist-cjs/install/index.js

@@ -1,6 +1,4 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_GRAMMAR_VERSION = exports.buildAddContextRuleArgs = exports.ADD_CONTEXT_RULE_SYMBOL = void 0;
 // Public entry for the install-argument builders.
 //
 // `buildAddContextRuleArgs` is the encoder `runInstallPolicy` uses to turn a
@@ -15,6 +13,19 @@ exports.DEFAULT_GRAMMAR_VERSION = exports.buildAddContextRuleArgs = exports.ADD_
 // Exported here rather than from the package root to keep the root surface
 // about synthesis, and because these are transaction-building primitives whose
 // callers should know they are reaching for them.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_GRAMMAR_VERSION = exports.buildAddContextRuleArgs = exports.ADD_CONTEXT_RULE_SYMBOL = exports.signerKey = exports.selectorsForContextType = exports.permittedSelectors = exports.intersectSelectors = exports.findAuthorityOverlaps = exports.effectiveSelectors = exports.ANY = void 0;
+// Cross-rule authority analysis. Exported because the check has to happen
+// wherever an install is BUILT, and a client that assembles its own
+// `add_context_rule` call never reaches `runInstallPolicy`.
+var authority_overlap_ts_1 = require("./authority-overlap.js");
+Object.defineProperty(exports, "ANY", { enumerable: true, get: function () { return authority_overlap_ts_1.ANY; } });
+Object.defineProperty(exports, "effectiveSelectors", { enumerable: true, get: function () { return authority_overlap_ts_1.effectiveSelectors; } });
+Object.defineProperty(exports, "findAuthorityOverlaps", { enumerable: true, get: function () { return authority_overlap_ts_1.findAuthorityOverlaps; } });
+Object.defineProperty(exports, "intersectSelectors", { enumerable: true, get: function () { return authority_overlap_ts_1.intersectSelectors; } });
+Object.defineProperty(exports, "permittedSelectors", { enumerable: true, get: function () { return authority_overlap_ts_1.permittedSelectors; } });
+Object.defineProperty(exports, "selectorsForContextType", { enumerable: true, get: function () { return authority_overlap_ts_1.selectorsForContextType; } });
+Object.defineProperty(exports, "signerKey", { enumerable: true, get: function () { return authority_overlap_ts_1.signerKey; } });
 var build_add_context_rule_ts_1 = require("./build-add-context-rule.js");
 Object.defineProperty(exports, "ADD_CONTEXT_RULE_SYMBOL", { enumerable: true, get: function () { return build_add_context_rule_ts_1.ADD_CONTEXT_RULE_SYMBOL; } });
 Object.defineProperty(exports, "buildAddContextRuleArgs", { enumerable: true, get: function () { return build_add_context_rule_ts_1.buildAddContextRuleArgs; } });

package/dist-cjs/install/read-account-rules.d.ts

@@ -0,0 +1,79 @@
+import { rpc, xdr } from '@stellar/stellar-sdk';
+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 declare const K_DOC = 1;
+/** Persistent-storage key for a rule's stored document:
+ *  `(account, rule_id, K_DOC)`. */
+export declare function docKeyScVal(smartAccount: string, ruleId: number): xdr.ScVal;
+/** Ledger key for the interpreter's persistent entry holding that document. */
+export declare function docLedgerKey(interpreter: string, smartAccount: string, ruleId: number): xdr.LedgerKey;
+/** 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 declare function decodeContextType(v: xdr.ScVal | undefined): ContextType;
+/** OZ `Signer::Delegated(Address) | Signer::External(Address, Bytes)`. */
+export declare function decodeSigner(v: xdr.ScVal): SignerDraft | undefined;
+/** A full OZ `ContextRule` as returned by `get_context_rule(id)`.
+ *  `predicate` is filled in separately from the ledger entry. */
+export declare function decodeContextRule(v: xdr.ScVal): ObservedRule | undefined;
+/** The interpreter's `StoredDoc { predicate_bytes }`. */
+export declare function decodeStoredPredicateBytes(v: xdr.ScVal): Buffer | undefined;
+/** 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 declare 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 declare function collectObservedRules(args: {
+    reader: AccountRuleReader;
+    smartAccount: string;
+    interpreterAddress: string;
+    maxRuleIdScan?: number;
+}): Promise<CollectedRules>;
+/**
+ * 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 declare function accountRuleReaderFromServer(server: rpc.Server, networkPassphrase: string): AccountRuleReader;

package/dist-cjs/install/read-account-rules.js

@@ -0,0 +1,252 @@
+"use strict";
+//! 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_RULE_ID_SCAN = exports.K_DOC = void 0;
+exports.docKeyScVal = docKeyScVal;
+exports.docLedgerKey = docLedgerKey;
+exports.decodeContextType = decodeContextType;
+exports.decodeSigner = decodeSigner;
+exports.decodeContextRule = decodeContextRule;
+exports.decodeStoredPredicateBytes = decodeStoredPredicateBytes;
+exports.collectObservedRules = collectObservedRules;
+exports.accountRuleReaderFromServer = accountRuleReaderFromServer;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const decode_ts_1 = require("../predicate/decode.js");
+/** `storage.rs` - the third element of the persistent doc key tuple. */
+exports.K_DOC = 1;
+/** Persistent-storage key for a rule's stored document:
+ *  `(account, rule_id, K_DOC)`. */
+function docKeyScVal(smartAccount, ruleId) {
+    return stellar_sdk_1.xdr.ScVal.scvVec([
+        new stellar_sdk_1.Address(smartAccount).toScVal(),
+        stellar_sdk_1.xdr.ScVal.scvU32(ruleId),
+        stellar_sdk_1.xdr.ScVal.scvU32(exports.K_DOC),
+    ]);
+}
+/** Ledger key for the interpreter's persistent entry holding that document. */
+function docLedgerKey(interpreter, smartAccount, ruleId) {
+    return stellar_sdk_1.xdr.LedgerKey.contractData(new stellar_sdk_1.xdr.LedgerKeyContractData({
+        contract: new stellar_sdk_1.Address(interpreter).toScAddress(),
+        key: docKeyScVal(smartAccount, ruleId),
+        durability: stellar_sdk_1.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, name) {
+    if (v.switch() !== stellar_sdk_1.xdr.ScValType.scvMap())
+        return undefined;
+    for (const entry of v.map() ?? []) {
+        const key = entry.key();
+        if (key.switch() === stellar_sdk_1.xdr.ScValType.scvSymbol() && key.sym().toString() === name) {
+            return entry.val();
+        }
+    }
+    return undefined;
+}
+function u32Of(v) {
+    return v?.switch() === stellar_sdk_1.xdr.ScValType.scvU32() ? v.u32() : undefined;
+}
+function addressOf(v) {
+    if (!v || v.switch() !== stellar_sdk_1.xdr.ScValType.scvAddress())
+        return undefined;
+    return stellar_sdk_1.Address.fromScAddress(v.address()).toString();
+}
+/** An enum variant of a `#[contracttype]` enum: `ScVal::Vec([Symbol, ...args])`. */
+function enumVariant(v) {
+    if (!v || v.switch() !== stellar_sdk_1.xdr.ScValType.scvVec())
+        return undefined;
+    const items = v.vec() ?? [];
+    const head = items[0];
+    if (!head || head.switch() !== stellar_sdk_1.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. */
+function decodeContextType(v) {
+    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() === stellar_sdk_1.xdr.ScValType.scvBytes() ? arg.bytes().toString('hex') : '';
+        return { kind: 'create_contract', wasmHash: hash };
+    }
+    return { kind: 'default' };
+}
+/** OZ `Signer::Delegated(Address) | Signer::External(Address, Bytes)`. */
+function decodeSigner(v) {
+    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() === stellar_sdk_1.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. */
+function decodeContextRule(v) {
+    const id = u32Of(mapField(v, 'id'));
+    if (id === undefined)
+        return undefined;
+    const signersVal = mapField(v, 'signers');
+    const signers = [];
+    if (signersVal?.switch() === stellar_sdk_1.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 = [];
+    if (policiesVal?.switch() === stellar_sdk_1.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 }`. */
+function decodeStoredPredicateBytes(v) {
+    const field = mapField(v, 'predicate_bytes');
+    if (!field || field.switch() !== stellar_sdk_1.xdr.ScValType.scvBytes())
+        return undefined;
+    return field.bytes();
+}
+/** 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. */
+exports.MAX_RULE_ID_SCAN = 512;
+/**
+ * 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.
+ */
+async function collectObservedRules(args) {
+    const count = await args.reader.getContextRuleCount(args.smartAccount);
+    const limit = args.maxRuleIdScan ?? exports.MAX_RULE_ID_SCAN;
+    const rules = [];
+    const unreadablePredicateRuleIds = [];
+    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 = (0, decode_ts_1.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.
+ */
+function accountRuleReaderFromServer(server, networkPassphrase) {
+    async function simulateCall(contract, method, ...args) {
+        const account = new stellar_sdk_1.Account(stellar_sdk_1.Keypair.random().publicKey(), '0');
+        const tx = new stellar_sdk_1.TransactionBuilder(account, { fee: stellar_sdk_1.BASE_FEE, networkPassphrase })
+            .addOperation(new stellar_sdk_1.Contract(contract).call(method, ...args))
+            .setTimeout(30)
+            .build();
+        const sim = await server.simulateTransaction(tx);
+        if (stellar_sdk_1.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', stellar_sdk_1.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() !== stellar_sdk_1.xdr.LedgerEntryType.contractData())
+                return undefined;
+            return entry.contractData().val();
+        },
+    };
+}

package/dist-cjs/predicate/decode.js

@@ -60,6 +60,15 @@ function expectSymbol(v, what) {
         throw malformed(`${what} is not a symbol`);
     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, what) {
+    if (!v || v.switch() !== stellar_sdk_1.xdr.ScValType.scvI128())
+        throw malformed(`${what} is not an i128`);
+    return (0, stellar_sdk_1.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, n, selector) {
@@ -89,6 +98,14 @@ function decodeSelectorLeaf(items, sym) {
                 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}'`);
@@ -125,7 +142,8 @@ function decodeNode(v) {
     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], `${op} children`).map(decodeNode);
             if (children.length === 0)
@@ -133,7 +151,10 @@ function decodeNode(v) {
             return { op, children };
         }
         case 'eq':
+        case 'lt':
         case 'lte':
+        case 'gt':
+        case 'gte':
             arity(items, 3, op);
             return {
                 op,