@crediolabs/policy-synth 0.1.18 → 0.3.0

package/dist/ir/types.d.ts

@@ -1,18 +1,14 @@
 /** Comparison operator. Mirrors NEAR-V2 `CompOp`. */
-export type IRCompOp = 'eq' | 'lt' | 'lte' | 'gt' | 'gte';
+export type IRCompOp = 'eq' | 'lte';
 /** Boolean combinator. Mirrors NEAR-V2 `LogicOp`. */
-export type IRLogic = 'and' | 'or';
-/** Vector match mode for a repeated arg. Mirrors NEAR-V2 `VecMode`. */
-export type IRVecMode = 'all' | 'any';
-/** Scalar value type. Mirrors NEAR-V2 `ScValType`, superset for OZ. */
-export type IRScalarType = 'address' | 'i128' | 'u128' | 'u32' | 'u64' | 'i64' | 'symbol' | 'bytes' | 'bool';
+export type IRLogic = 'and';
+/** Scalar value type. The subset the predicate grammar has a literal for. */
+export type IRScalarType = 'address' | 'i128' | 'u32' | 'symbol';
 /** WHERE in the authorized call a value is read. NEAR-V2 selectors first, OZ
  *  extensions after (an adapter that cannot express an extension flags it). */
 export type IRSelector = {
     kind: 'arg';
     argIndex: number;
-    fieldIndex?: number;
-    vecMode?: IRVecMode;
     scalarType: IRScalarType;
 } | {
     kind: 'arg_len';
@@ -23,29 +19,6 @@ export type IRSelector = {
     element: number;
     field: string;
     scalarType: IRScalarType;
-} | {
-    kind: 'calldata';
-    offset: number;
-    length: number;
-} | {
-    kind: 'value';
-} | {
-    kind: 'amount';
-    token: string;
-} | {
-    kind: 'window_spent';
-    token: string;
-    windowSeconds: number;
-} | {
-    kind: 'invocation_count';
-    windowSeconds: number;
-} | {
-    kind: 'now';
-} | {
-    kind: 'valid_until';
-} | {
-    kind: 'oracle_price';
-    asset: string;
 };
 /** A single comparison leaf. `value` is a decimal/hex string (i128-safe;
  *  never a JS number). */
@@ -53,21 +26,14 @@ export interface IRCompare {
     selector: IRSelector;
     operator: IRCompOp;
     value: string;
-    /** Decimal basis of `value`, for selectors whose comparand is not on a basis
-     *  the contract can infer. Set for `oracle_price`, where prices normalise to
-     *  9 dp and an undeclared basis fails OPEN. */
-    valueDecimals?: number;
 }
 /** Condition tree. NEAR-V2 guard/constraint are flat And/Or; the IR allows
  *  nesting + `not` + `in` + `eq_seq` so the same IR can later lower to the OZ
  *  predicate DSL. Week-1 adapters only lower the flat supported subset and flag
  *  the rest. */
 export type IRCondition = {
-    op: 'and' | 'or';
+    op: 'and';
     children: IRCondition[];
-} | {
-    op: 'not';
-    child: IRCondition;
 } | {
     op: 'compare';
     compare: IRCompare;
@@ -85,56 +51,21 @@ export type IRCondition = {
     op: 'eq_seq';
     selector: IRSelector;
     values: string[];
-}
-/** A swap's output floor, expressed against its own input: the output arg
- *  must be at least `inArgIndex * num / den`.
- *
- *  It is its own construct because `compare` bounds a selector against a
- *  CONSTANT, and a slippage floor has no constant to bound against - the
- *  acceptable output depends on the input of the same call. Encoding the
- *  recorded output as a constant would pin a policy to one trade size.
- *
- *  `num/den` is the caller's minimum acceptable output per unit of input.
- *  It is never derived from the recording: the recorded rate is a price at
- *  one moment, and freezing it as policy would deny normal trades later.
- *  Adapters that cannot express it (the OZ built-ins) flag it `uncovered`. */
- | {
-    op: 'slippage_floor';
-    outArgIndex: number;
-    inArgIndex: number;
-    num: string;
-    den: string;
 };
 export interface IRPolicyRule {
-    /** NEAR-V2 roles whitelist (empty = any; owner exempt). */
-    roles: string[];
     /** NEAR-V2 scope filter; each field optional (absent = wildcard). */
     scope: {
-        chainId?: number;
         contract?: string;
         method?: string;
     };
-    /** NEAR-V2 guard (applicability; skip the rule when it fails). */
-    guard?: IRCondition;
     /** NEAR-V2 constraint (AND; reject the transaction when any fails). */
     constraints: IRCondition[];
-    /** M-of-N approval (OZ threshold primitives). */
-    approval?: {
-        kind: 'threshold';
-        threshold: number;
-        weights?: Record<string, number>;
-    };
-    /** OZ context-rule expiry. */
+    /** OZ context-rule expiry, by ledger sequence - the only clock the OZ
+     *  account model exposes to a rule. */
     expiry?: {
         validUntilLedger?: number;
-        validUntilUnixSeconds?: number;
     };
 }
 export interface PolicyIR {
-    /** NEAR-V2 PolicyChain. */
-    chain: 'stellar' | 'evm';
-    /** NEAR-V2 DefaultBehavior. OZ context rules are deny-by-default, so
-     *  `deny_all` is the OZ default fallback when no rule matches. */
-    defaultBehavior: 'allow_all' | 'deny_all';
     rules: IRPolicyRule[];
 }

package/dist/ir/types.js

@@ -4,8 +4,6 @@
 // Tree) that every CustodyAdapter compiles FROM. It generalizes the NEAR-V2
 // policy schema (roles / scope filter / guard / constraint / comparison leaves /
 // default behaviour) into one chain-neutral shape and extends it with the
-// OZ-only selectors (spend window, oracle price, invocation count, time) so a
 // single IR can serve every backend. NEAR-V2 has no stateful spend window,
-// oracle, time/expiry, or invocation-count; those are marked as OZ extensions
 // below and are only lowered by adapters that declare support for them.
 export {};

package/dist/predicate/decode.d.ts

@@ -2,7 +2,7 @@ import { xdr } from '@stellar/stellar-sdk';
 import type { PredicateLeaf, PredicateNode } from '../types.ts';
 /** One leaf. Order of the bare-literal checks mirrors `decode_leaf` in dsl.rs. */
 export declare function decodeLeaf(v: xdr.ScVal): PredicateLeaf;
-/** One node. `not` wraps a NODE; the comparison ops wrap two LEAVES. */
+/** One node. The comparison ops wrap two LEAVES. */
 export declare function decodeNode(v: xdr.ScVal): PredicateNode;
 /** Decode a predicate from the wire bytes the interpreter stores.
  *

package/dist/predicate/decode.js

@@ -55,21 +55,6 @@ function expectSymbol(v, what) {
         throw malformed(`${what} is not a symbol`);
     return v.sym().toString();
 }
-function expectAddress(v, what) {
-    if (!v || v.switch() !== xdr.ScValType.scvAddress())
-        throw malformed(`${what} is not an address`);
-    return Address.fromScAddress(v.address()).toString();
-}
-function expectU64(v, what) {
-    if (!v || v.switch() !== xdr.ScValType.scvU64())
-        throw malformed(`${what} is not a u64`);
-    return v.u64().toString();
-}
-function expectI128(v, what) {
-    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, n, selector) {
@@ -99,48 +84,6 @@ 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'),
-            };
-        case 'amount':
-            arity(items, 2, sym);
-            return { kind: 'amount', token: expectAddress(items[1], 'amount token') };
-        case 'window_spent':
-            arity(items, 3, sym);
-            return {
-                kind: 'window_spent',
-                token: expectAddress(items[1], 'window_spent token'),
-                windowSeconds: Number(expectU64(items[2], 'window_spent windowSeconds')),
-            };
-        case 'now':
-            arity(items, 1, sym);
-            return { kind: 'now' };
-        case 'valid_until':
-            // The encoder refuses to emit this and the interpreter refuses it at
-            // install, so it cannot appear in a document that installed. Decoding it
-            // anyway would present a rule the chain would never have accepted.
-            throw malformed('valid_until is not a usable predicate leaf');
-        case 'invocation_count':
-            arity(items, 2, sym);
-            return {
-                kind: 'invocation_count_in_window',
-                windowSecs: Number(expectU64(items[1], 'invocation_count windowSecs')),
-            };
-        case 'oracle_price':
-            arity(items, 2, sym);
-            return { kind: 'oracle_price', asset: expectAddress(items[1], 'oracle_price asset') };
-        case 'oracle_threshold':
-            arity(items, 3, sym);
-            return {
-                kind: 'oracle_threshold',
-                value: expectI128(items[1], 'oracle_threshold value'),
-                decimals: expectU32(items[2], 'oracle_threshold decimals'),
-            };
         default:
             // Deliberately NOT a literal_vec fallback - see the header note.
             throw malformed(`unknown selector symbol '${sym}'`);
@@ -164,39 +107,28 @@ export function decodeLeaf(v) {
             return { kind: 'literal_symbol', value: v.sym().toString() };
         case xdr.ScValType.scvU32():
             return { kind: 'literal_u32', value: v.u32() };
-        case xdr.ScValType.scvU64():
-            return { kind: 'literal_u64', value: v.u64().toString() };
         case xdr.ScValType.scvI128():
             return { kind: 'literal_i128', value: scValToBigInt(v).toString() };
-        case xdr.ScValType.scvBytes():
-            return { kind: 'literal_bytes', value: Buffer.from(v.bytes()).toString('hex') };
         default:
             throw malformed(`unsupported leaf value type ${v.switch().name}`);
     }
 }
-/** One node. `not` wraps a NODE; the comparison ops wrap two LEAVES. */
+/** One node. The comparison ops wrap two LEAVES. */
 export function decodeNode(v) {
     const items = expectVec(v, 'node');
     const op = selectorSymbol(items);
     if (op === null)
         throw malformed('node does not start with an operator symbol');
     switch (op) {
-        case 'and':
-        case 'or': {
+        case 'and': {
             arity(items, 2, op);
             const children = expectVec(items[1], `${op} children`).map(decodeNode);
             if (children.length === 0)
                 throw malformed(`${op} has no children`);
             return { op, children };
         }
-        case 'not':
-            arity(items, 2, op);
-            return { op: 'not', child: decodeNode(items[1]) };
         case 'eq':
-        case 'lt':
         case 'lte':
-        case 'gt':
-        case 'gte':
             arity(items, 3, op);
             return {
                 op,