@crediolabs/policy-synth 0.1.15 → 0.1.16

package/dist/run/index.d.ts

@@ -4,7 +4,7 @@ import { getInterpreterInfo } from '../install/get-interpreter-info.ts';
 import type { SimulationResult } from '../verify/envelope.ts';
 import { type RecordTransactionInput, type SimulatePolicyInput, type SynthesizePolicyInput, type VerifyPolicyInput } from './schemas.ts';
 export type { GetInterpreterInfoInput, InstallPolicyInput, RecordTransactionInput, RevokePolicyInput, SimulatePolicyInput, SynthesizePolicyInput, VerifyPolicyInput, } from './schemas.ts';
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, } from './schemas.ts';
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, VerifyPolicyInputSchema, } from './schemas.ts';
 export type RunRecordTransactionInput = RecordTransactionInput;
 export type RunSynthesizePolicyInput = SynthesizePolicyInput;
 export type RunSimulatePolicyInput = SimulatePolicyInput;
@@ -59,10 +59,12 @@ export declare function runVerifyPolicy(raw: unknown): Promise<ToolResponse<true
  *  separate `interpreter.install` call is needed or possible.
  *
  *  Default-deny: an interpreter policy address other than the pinned
- *  testnet interpreter is REFUSED (the smart account would delegate to
- *  an interpreter the caller controls); the same applies to a non-pinned
- *  RPC URL (the auth nonce the wallet signs comes from the RPC). Both
- *  gates accept an explicit opt-in flag. */
+ *  interpreter for the selected network is REFUSED (the smart account
+ *  would delegate to an interpreter the caller controls); the same
+ *  applies to a non-pinned RPC URL (the auth nonce the wallet signs
+ *  comes from the RPC). Both gates accept an explicit opt-in flag.
+ *  Pin selection follows `input.network` (defaults to `testnet` so the
+ *  pre-mainnet callers keep working unchanged). */
 export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<BuildInstallPolicyResult>>;
 /** `revoke_policy` body - thin wrapper over `buildRevokePolicyXdr`.
  *  Emits an unsigned XDR for `account.remove_context_rule(ruleId)`; the
@@ -71,14 +73,23 @@ export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<Bui
  *
  *  Same RPC pin as install: a non-pinned `rpcUrl` is refused unless
  *  `allowUnpinnedRpcUrl: true`. Revoke does not carry an interpreter
- *  policy payload, so the interpreter pin is not re-checked here. */
+ *  policy payload, so the interpreter pin is not re-checked here.
+ *  Pin selection follows `input.network` (defaults to `testnet`). */
 export declare function runRevokePolicy(raw: unknown): Promise<ToolResponse<BuildRevokePolicyResult>>;
 /** `get_interpreter_info` body - thin wrapper over `getInterpreterInfo`.
  *  Returns the pinned deployment fingerprint + an optional live
  *  `grammar_version()` comparison. The audit field is deliberately
  *  OMITTED (phase-04's "audit #44" has no source of truth in the repo -
  *  fabricating it would be a lie on a security surface; the live
- *  mismatch check is worth MORE). */
+ *  mismatch check is worth MORE).
+ *
+ *  Network-aware: `input.network` selects which interpreter pin and RPC
+ *  to use. Mainnet was rolled out 2026-08-04 - the same wasm hash was
+ *  uploaded to mainnet as was exercised on testnet, so a single
+ *  `PINNED_INTERPRETER_WASM_SHA256` constant backs both networks
+ *  (DEPLOYMENTS.md:25-27). The address differs because instance ids are
+ *  network-scoped. UNAUDITED at the time of writing - see
+ *  DEPLOYMENTS.md:29-32 for what is still pending. */
 export declare function runGetInterpreterInfo(raw: unknown): Promise<ToolResponse<ReturnType<typeof getInterpreterInfo>>>;
 /** Build a canonical ToolError for a thrown exception caught by the tool
  *  envelope. The MCP SDK stringifies thrown objects as "[object Object]" by

package/dist/run/index.js

@@ -22,12 +22,12 @@ import { placeholderOzConfig, recordTransaction, synthesizeFromMandate, synthesi
 import { buildInstallPolicyXdr, buildRevokePolicyXdr, rpcClientFromServer, } from "../install/build-install-policy.js";
 import { getInterpreterInfo } from "../install/get-interpreter-info.js";
 import { simulatePolicy, verifyPolicy } from "../verify/index.js";
-import { GetInterpreterInfoInputSchema, InstallPolicyInputSchema, NETWORK_PASSPHRASES, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, TESTNET_RPC_URL, VerifyPolicyInputSchema, } from "./schemas.js";
+import { GetInterpreterInfoInputSchema, InstallPolicyInputSchema, NETWORK_PASSPHRASES, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_WASM_SHA256, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, VerifyPolicyInputSchema, } from "./schemas.js";
 // Re-export the underlying Zod schemas so the MCP package (and any other
 // downstream consumer) can import the canonical input shapes from the same
 // module that owns the tool-body glue. The strict schemas are the source of
 // truth - MCP tool shapes are derived from them.
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, } from "./schemas.js";
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, VerifyPolicyInputSchema, } from "./schemas.js";
 /** `record_transaction` body - wraps `recordTransaction`. The tool input
  *  matches the core RecordInput minus the injected `fetcher` (the transport
  *  layer does not own the RPC). Returns the core ToolResponse unchanged.
@@ -199,10 +199,12 @@ export async function runVerifyPolicy(raw) {
  *  separate `interpreter.install` call is needed or possible.
  *
  *  Default-deny: an interpreter policy address other than the pinned
- *  testnet interpreter is REFUSED (the smart account would delegate to
- *  an interpreter the caller controls); the same applies to a non-pinned
- *  RPC URL (the auth nonce the wallet signs comes from the RPC). Both
- *  gates accept an explicit opt-in flag. */
+ *  interpreter for the selected network is REFUSED (the smart account
+ *  would delegate to an interpreter the caller controls); the same
+ *  applies to a non-pinned RPC URL (the auth nonce the wallet signs
+ *  comes from the RPC). Both gates accept an explicit opt-in flag.
+ *  Pin selection follows `input.network` (defaults to `testnet` so the
+ *  pre-mainnet callers keep working unchanged). */
 export async function runInstallPolicy(raw) {
     const parsed = InstallPolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
@@ -212,17 +214,20 @@ export async function runInstallPolicy(raw) {
         };
     }
     const input = parsed.data;
+    const network = input.network ?? 'testnet';
     // ---- Pinning gates (default-deny) ----
-    const pinningError = enforceInterpreterPin(input.rule.policies, input.allowUnpinnedInterpreter);
+    const expectedInterpreter = PINNED_INTERPRETER_ADDRESS_BY_NETWORK[network];
+    const expectedRpc = RPC_URL_BY_NETWORK[network];
+    const pinningError = enforceInterpreterPin(input.rule.policies, input.allowUnpinnedInterpreter, expectedInterpreter);
     if (pinningError) {
         return { ok: false, error: pinningError };
     }
-    if (input.rpcUrl && input.rpcUrl !== TESTNET_RPC_URL && input.allowUnpinnedRpcUrl !== true) {
+    if (input.rpcUrl && input.rpcUrl !== expectedRpc && input.allowUnpinnedRpcUrl !== true) {
         return {
             ok: false,
             error: {
                 code: 'INSTALL_BUILD_FAILED',
-                message: `install_policy: rpcUrl must equal the pinned TESTNET_RPC_URL; set allowUnpinnedRpcUrl: true to opt in to a custom endpoint`,
+                message: `install_policy: rpcUrl must equal the pinned ${expectedRpc} (${network}); set allowUnpinnedRpcUrl: true to opt in to a custom endpoint`,
                 severity: 'error',
                 retryable: false,
                 remediation: { toolCall: { name: 'install_policy', args: {} } },
@@ -231,7 +236,7 @@ export async function runInstallPolicy(raw) {
     }
     let rpcClient;
     try {
-        rpcClient = buildRpcClientFromInput(input.rpcUrl);
+        rpcClient = buildRpcClientFromInput(input.rpcUrl, network);
     }
     catch (e) {
         return {
@@ -248,7 +253,7 @@ export async function runInstallPolicy(raw) {
         const result = await buildInstallPolicyXdr({
             smartAccount: input.smartAccount,
             sourceAccount: input.sourceAccount,
-            networkPassphrase: NETWORK_PASSPHRASES.testnet,
+            networkPassphrase: NETWORK_PASSPHRASES[network],
             rule: input.rule,
             installNonce: input.installNonce,
             encodedPredicate,
@@ -272,7 +277,8 @@ export async function runInstallPolicy(raw) {
  *
  *  Same RPC pin as install: a non-pinned `rpcUrl` is refused unless
  *  `allowUnpinnedRpcUrl: true`. Revoke does not carry an interpreter
- *  policy payload, so the interpreter pin is not re-checked here. */
+ *  policy payload, so the interpreter pin is not re-checked here.
+ *  Pin selection follows `input.network` (defaults to `testnet`). */
 export async function runRevokePolicy(raw) {
     const parsed = RevokePolicyInputSchema.safeParse(raw);
     if (!parsed.success) {
@@ -282,12 +288,14 @@ export async function runRevokePolicy(raw) {
         };
     }
     const input = parsed.data;
-    if (input.rpcUrl && input.rpcUrl !== TESTNET_RPC_URL && input.allowUnpinnedRpcUrl !== true) {
+    const network = input.network ?? 'testnet';
+    const expectedRpc = RPC_URL_BY_NETWORK[network];
+    if (input.rpcUrl && input.rpcUrl !== expectedRpc && input.allowUnpinnedRpcUrl !== true) {
         return {
             ok: false,
             error: {
                 code: 'REVOKE_BUILD_FAILED',
-                message: `revoke_policy: rpcUrl must equal the pinned TESTNET_RPC_URL; set allowUnpinnedRpcUrl: true to opt in to a custom endpoint`,
+                message: `revoke_policy: rpcUrl must equal the pinned ${expectedRpc} (${network}); set allowUnpinnedRpcUrl: true to opt in to a custom endpoint`,
                 severity: 'error',
                 retryable: false,
                 remediation: { toolCall: { name: 'revoke_policy', args: {} } },
@@ -296,7 +304,7 @@ export async function runRevokePolicy(raw) {
     }
     let rpcClient;
     try {
-        rpcClient = buildRpcClientFromInput(input.rpcUrl);
+        rpcClient = buildRpcClientFromInput(input.rpcUrl, network);
     }
     catch (e) {
         return {
@@ -309,7 +317,7 @@ export async function runRevokePolicy(raw) {
             smartAccount: input.smartAccount,
             sourceAccount: input.sourceAccount,
             ruleId: input.ruleId,
-            networkPassphrase: NETWORK_PASSPHRASES.testnet,
+            networkPassphrase: NETWORK_PASSPHRASES[network],
             rpc: rpcClient,
             ...(input.baseFee !== undefined ? { baseFee: input.baseFee } : {}),
         });
@@ -327,7 +335,15 @@ export async function runRevokePolicy(raw) {
  *  `grammar_version()` comparison. The audit field is deliberately
  *  OMITTED (phase-04's "audit #44" has no source of truth in the repo -
  *  fabricating it would be a lie on a security surface; the live
- *  mismatch check is worth MORE). */
+ *  mismatch check is worth MORE).
+ *
+ *  Network-aware: `input.network` selects which interpreter pin and RPC
+ *  to use. Mainnet was rolled out 2026-08-04 - the same wasm hash was
+ *  uploaded to mainnet as was exercised on testnet, so a single
+ *  `PINNED_INTERPRETER_WASM_SHA256` constant backs both networks
+ *  (DEPLOYMENTS.md:25-27). The address differs because instance ids are
+ *  network-scoped. UNAUDITED at the time of writing - see
+ *  DEPLOYMENTS.md:29-32 for what is still pending. */
 export async function runGetInterpreterInfo(raw) {
     const parsed = GetInterpreterInfoInputSchema.safeParse(raw);
     if (!parsed.success) {
@@ -338,34 +354,15 @@ export async function runGetInterpreterInfo(raw) {
     }
     const input = parsed.data;
     const network = input.network ?? 'testnet';
-    // Asking about mainnet used to return the TESTNET pin with `network:
-    // 'mainnet'` stamped on it. DEPLOYMENTS.md:3 says plainly "Testnet only.
-    // Nothing is deployed to mainnet yet", so that answer described a contract
-    // that does not exist at an address that is not on that network. This tool
-    // exists to tell a caller what they are installing against; inventing a
-    // mainnet deployment is the same failure as inventing an audit reference.
-    if (network === 'mainnet') {
-        return {
-            ok: false,
-            error: {
-                code: 'RECORDING_FAILED',
-                message: 'get_interpreter_info: no interpreter is deployed to mainnet. The pinned address and wasm hash are testnet-only; mainnet deployment is gated on the interpreter audit.',
-                severity: 'error',
-                retryable: false,
-                remediation: {
-                    toolCall: { name: 'get_interpreter_info', args: { network: 'testnet' } },
-                },
-            },
-        };
-    }
+    const pinnedAddress = PINNED_INTERPRETER_ADDRESS_BY_NETWORK[network];
     try {
         let deployedGrammarVersion;
         if (input.verifyLive === true) {
-            const rpcClient = buildRpcClientFromInput(input.rpcUrl);
-            deployedGrammarVersion = await rpcClient.getContractVersion(PINNED_INTERPRETER_TESTNET_ADDRESS);
+            const rpcClient = buildRpcClientFromInput(input.rpcUrl, network);
+            deployedGrammarVersion = await rpcClient.getContractVersion(pinnedAddress);
         }
         const info = getInterpreterInfo({
-            pinnedAddress: PINNED_INTERPRETER_TESTNET_ADDRESS,
+            pinnedAddress,
             pinnedGrammarVersion: PINNED_INTERPRETER_GRAMMAR_VERSION,
             pinnedWasmHash: PINNED_INTERPRETER_WASM_SHA256,
             network,
@@ -380,41 +377,40 @@ export async function runGetInterpreterInfo(raw) {
         };
     }
 }
-/** Build an InstallRpcClient from an optional URL override, falling back
- *  to the public testnet RPC (matching the design-decision rule that we
- *  reuse `record/rpc.ts` and never hard-code a different RPC client). */
-function buildRpcClientFromInput(urlOverride) {
-    if (urlOverride) {
-        return rpcClientFromServer(new rpc.Server(urlOverride, { allowHttp: false }), NETWORK_PASSPHRASES.testnet);
-    }
-    // Default: public testnet RPC. Matches the brief; the mainnet pin would
-    // need a separate deploy and is out of scope for this tool.
-    //
+/** Build an InstallRpcClient from an optional URL override + selected
+ *  network, falling back to the pinned RPC for the network. The caller
+ *  has already been gated against the pinned URL elsewhere, so the
+ *  fallback here only ever picks from a finite, audited pair. */
+function buildRpcClientFromInput(urlOverride, network) {
+    const url = urlOverride ?? RPC_URL_BY_NETWORK[network];
+    const passphrase = NETWORK_PASSPHRASES[network];
     // NOT `createRpcServer` - that returns an RpcFetcher, a bare
     // `(hash) => Promise<SorobanTxResponse|null>` for the RECORDER. Passing it
     // here produced a client whose `getAccount` was undefined, so every live
     // call died with "server.getAccount is not a function". The install path
     // needs the full Server surface.
-    return rpcClientFromServer(new rpc.Server(TESTNET_RPC_URL, { allowHttp: false }), NETWORK_PASSPHRASES.testnet);
+    return rpcClientFromServer(new rpc.Server(url, { allowHttp: false }), passphrase);
 }
 /** Default-deny: refuse any interpreter policy whose address differs from
- *  the pinned testnet interpreter. An interpreter the caller controls
- *  can permit anything, so the smart account's authorization must bind
- *  to the pinned contract unless the caller explicitly opts in via
- *  `allowUnpinnedInterpreter`. OZ built-in policies are not interpreters
- *  and pass through unchanged. Returns a ToolError to surface through
- *  the run-layer envelope, or null when the policies are all pinned. */
-function enforceInterpreterPin(policies, allowUnpinned) {
+ *  the pinned interpreter for the selected network. An interpreter the
+ *  caller controls can permit anything, so the smart account's
+ *  authorization must bind to the pinned contract unless the caller
+ *  explicitly opts in via `allowUnpinnedInterpreter`. OZ built-in
+ *  policies are not interpreters and pass through unchanged. Returns a
+ *  ToolError to surface through the run-layer envelope, or null when the
+ *  policies are all pinned. The caller resolves the expected pin per
+ *  network; this function stays pure so it is easy to test. */
+function enforceInterpreterPin(policies, allowUnpinned, expectedInterpreterAddress) {
     for (const p of policies) {
         if (p.kind !== 'interpreter')
             continue;
-        if (p.interpreterAddress === PINNED_INTERPRETER_TESTNET_ADDRESS)
+        if (p.interpreterAddress === expectedInterpreterAddress)
             continue;
         if (allowUnpinned === true)
             continue;
         return {
             code: 'INSTALL_BUILD_FAILED',
-            message: `install_policy: interpreter policy address ${p.interpreterAddress} != pinned ${PINNED_INTERPRETER_TESTNET_ADDRESS}; set allowUnpinnedInterpreter: true to opt in to a non-pinned interpreter`,
+            message: `install_policy: interpreter policy address ${p.interpreterAddress} != pinned ${expectedInterpreterAddress}; set allowUnpinnedInterpreter: true to opt in to a non-pinned interpreter`,
             severity: 'error',
             retryable: false,
             remediation: { toolCall: { name: 'install_policy', args: {} } },

package/dist/run/schemas.d.ts

@@ -2641,9 +2641,16 @@ export declare const VerifyPolicyInputSchema: z.ZodObject<{
     }> | undefined;
 }>;
 export type VerifyPolicyInput = z.infer<typeof VerifyPolicyInputSchema>;
-/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:156-157.
+/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:128.
  *  Single source for the MCP layer; do not embed elsewhere. */
 export declare const PINNED_INTERPRETER_TESTNET_ADDRESS = "CDR4NLV22STCXFGZPNKDQTEANWLF7LZ6AJLY6B7CLJXKHDZGYJWIOKGP";
+/** Pinned interpreter address (mainnet). Mirrors DEPLOYMENTS.md:18. Mainnet
+ *  has now been deployed (2026-08-04); the mainnet interpreter IS the binary
+ *  that was exercised on testnet (same wasm sha256, see
+ *  PINNED_INTERPRETER_WASM_SHA256). The address differs because instance
+ *  ids are network-scoped. UNAUDITED at the time of writing - see
+ *  DEPLOYMENTS.md:29-32 for the recorded decision and what is still pending. */
+export declare const PINNED_INTERPRETER_MAINNET_ADDRESS = "CALZAMUPREIRY4TULBEXIK77AUTOEJG63XLCPUWEHHQDOVK6ZVVS7VQ2";
 /** Pinned interpreter wasm sha256 (hex). Mirrors DEPLOYMENTS.md:156-157. */
 export declare const PINNED_INTERPRETER_WASM_SHA256 = "6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443";
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
@@ -2654,6 +2661,17 @@ export declare const PINNED_INTERPRETER_GRAMMAR_VERSION = 1;
  *  than a Server; the two are deliberately different surfaces, so this is
  *  pinned beside the addresses it is used with rather than shared. */
 export declare const TESTNET_RPC_URL = "https://soroban-testnet.stellar.org";
+/** Mainnet Soroban RPC. Pinned beside MAINNET counterparts so the install
+ *  and get_interpreter_info gates compare against the matching network's
+ *  RPC rather than always testnet. Public mainnet endpoint, the same one
+ *  the deploy script hit during the 2026-08-04 mainnet rollout. */
+export declare const MAINNET_RPC_URL = "https://mainnet.sorobanrpc.com";
+/** Pin + RPC lookup for the gate enforcement. The interpreters' wasm sha256
+ *  is identical across both networks (the same binary was uploaded both
+ *  places; DEPLOYMENTS.md:25-27), so `PINNED_INTERPRETER_WASM_SHA256` stays
+ *  a single constant - only the addresses and RPCs are network-scoped. */
+export declare const PINNED_INTERPRETER_ADDRESS_BY_NETWORK: Record<Network, string>;
+export declare const RPC_URL_BY_NETWORK: Record<Network, string>;
 /** Soroban `valid_until` window (ledgers) added to the latest ledger when
  *  building the auth entry. ~25 minutes at 5s/ledger. */
 export declare const DEFAULT_AUTH_VALID_UNTIL_LEDGERS = 300;
@@ -2667,6 +2685,14 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     /** The signer that authorises the install (G... wallet). Used only for
      *  sequence number + auth nonce simulation; never persisted, never signed. */
     sourceAccount: z.ZodString;
+    /** Target network for the install. Selects which interpreter pin and
+     *  which RPC URL are valid by default. Defaults to `testnet` so the
+     *  pre-mainnet callers keep working: they were always pointing at
+     *  the testnet pin, so defaulting testnet here is the conservative
+     *  continuation, NOT a silent fall-through that bypasses the gate.
+     *  A caller that targets mainnet MUST set this to `mainnet` (the
+     *  pin and RPC pin do not move by themselves). */
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
     /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape. */
     rule: z.ZodEffects<z.ZodObject<{
         contextRuleType: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
@@ -3121,18 +3147,22 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     }, z.ZodTypeAny, "passthrough">>;
     /** Per-rule install nonce; 1 for a fresh install. */
     installNonce: z.ZodNumber;
-    /** Optional RPC URL override. Defaults to the public testnet endpoint
-     *  (`TESTNET_RPC_URL`); the override is refused unless
+    /** Optional RPC URL override. Defaults to the pinned RPC for the
+     *  selected `network` (testnet by default, mainnet when
+     *  `network: 'mainnet'`); the override is refused unless
      *  `allowUnpinnedRpcUrl: true`, because the auth nonce and
      *  rootInvocation in the response come from whichever RPC answered. */
     rpcUrl: z.ZodOptional<z.ZodString>;
     /** Opt-in to using a non-pinned RPC URL. Without this flag the tool
-     *  refuses any `rpcUrl` other than `TESTNET_RPC_URL` because the
-     *  caller's auth-digest binds to whatever the RPC returned. */
+     *  refuses any `rpcUrl` other than the pinned RPC for the selected
+     *  network because the caller's auth-digest binds to whatever the
+     *  RPC returned. */
     allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
     /** Opt-in to pointing the rule's interpreter policy at any address
-     *  other than the pinned testnet interpreter. Default-deny: a caller
-     *  that controls the interpreter can permit everything. */
+     *  other than the pinned interpreter for the selected network.
+     *  Default-deny: a caller that controls the interpreter can permit
+     *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
+     *  the mainnet pin is its own deny-by-default anchor. */
     allowUnpinnedInterpreter: z.ZodOptional<z.ZodBoolean>;
     /** Base fee in stroops; defaults to BASE_FEE (100). */
     baseFee: z.ZodOptional<z.ZodNumber>;
@@ -3175,6 +3205,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -3218,6 +3249,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -3261,6 +3293,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -3304,6 +3337,7 @@ export declare const InstallPolicyInputSchema: z.ZodEffects<z.ZodObject<{
     } & {
         [k: string]: unknown;
     };
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     allowUnpinnedInterpreter?: boolean | undefined;
@@ -3318,9 +3352,12 @@ export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
      *  verify, since the account's source is not in this repo. Proven on
      *  testnet: the account's deployer can revoke. */
     sourceAccount: z.ZodString;
+    /** Target network for the revoke. Same `testnet`-default as install,
+     *  so pre-mainnet callers keep working without an explicit flag. */
+    network: z.ZodOptional<z.ZodEnum<["mainnet", "testnet"]>>;
     /** The rule id to remove from the smart account + interpreter. */
     ruleId: z.ZodNumber;
-    /** Optional RPC URL override; same pin as install. */
+    /** Optional RPC URL override; same per-network pin as install. */
     rpcUrl: z.ZodOptional<z.ZodString>;
     /** Opt-in to using a non-pinned RPC URL. Same semantics as install. */
     allowUnpinnedRpcUrl: z.ZodOptional<z.ZodBoolean>;
@@ -3330,6 +3367,7 @@ export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     smartAccount: string;
     sourceAccount: string;
     ruleId: number;
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     baseFee?: number | undefined;
@@ -3337,6 +3375,7 @@ export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     smartAccount: string;
     sourceAccount: string;
     ruleId: number;
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     baseFee?: number | undefined;
@@ -3344,6 +3383,7 @@ export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     smartAccount: string;
     sourceAccount: string;
     ruleId: number;
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     baseFee?: number | undefined;
@@ -3351,6 +3391,7 @@ export declare const RevokePolicyInputSchema: z.ZodEffects<z.ZodObject<{
     smartAccount: string;
     sourceAccount: string;
     ruleId: number;
+    network?: "mainnet" | "testnet" | undefined;
     rpcUrl?: string | undefined;
     allowUnpinnedRpcUrl?: boolean | undefined;
     baseFee?: number | undefined;

package/dist/run/schemas.js

@@ -424,9 +424,16 @@ const MandateSpecSchemaForRule = z
 // install/revoke/get_info schemas live HERE (after the helper) so the const
 // reference resolves at module init. They are the new tools on top of the
 // existing four.
-/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:156-157.
+/** Pinned interpreter address (testnet). Mirrors DEPLOYMENTS.md:128.
  *  Single source for the MCP layer; do not embed elsewhere. */
 export const PINNED_INTERPRETER_TESTNET_ADDRESS = 'CDR4NLV22STCXFGZPNKDQTEANWLF7LZ6AJLY6B7CLJXKHDZGYJWIOKGP';
+/** Pinned interpreter address (mainnet). Mirrors DEPLOYMENTS.md:18. Mainnet
+ *  has now been deployed (2026-08-04); the mainnet interpreter IS the binary
+ *  that was exercised on testnet (same wasm sha256, see
+ *  PINNED_INTERPRETER_WASM_SHA256). The address differs because instance
+ *  ids are network-scoped. UNAUDITED at the time of writing - see
+ *  DEPLOYMENTS.md:29-32 for the recorded decision and what is still pending. */
+export const PINNED_INTERPRETER_MAINNET_ADDRESS = 'CALZAMUPREIRY4TULBEXIK77AUTOEJG63XLCPUWEHHQDOVK6ZVVS7VQ2';
 /** Pinned interpreter wasm sha256 (hex). Mirrors DEPLOYMENTS.md:156-157. */
 export const PINNED_INTERPRETER_WASM_SHA256 = '6e6c13d93e197aa380303a42cd120f5ddb080dd36ef2a343ee1dbd04ca52a443';
 /** The grammar version the interpreter enforces (matches SELF_VERSION in
@@ -437,6 +444,23 @@ export const PINNED_INTERPRETER_GRAMMAR_VERSION = 1;
  *  than a Server; the two are deliberately different surfaces, so this is
  *  pinned beside the addresses it is used with rather than shared. */
 export const TESTNET_RPC_URL = 'https://soroban-testnet.stellar.org';
+/** Mainnet Soroban RPC. Pinned beside MAINNET counterparts so the install
+ *  and get_interpreter_info gates compare against the matching network's
+ *  RPC rather than always testnet. Public mainnet endpoint, the same one
+ *  the deploy script hit during the 2026-08-04 mainnet rollout. */
+export const MAINNET_RPC_URL = 'https://mainnet.sorobanrpc.com';
+/** Pin + RPC lookup for the gate enforcement. The interpreters' wasm sha256
+ *  is identical across both networks (the same binary was uploaded both
+ *  places; DEPLOYMENTS.md:25-27), so `PINNED_INTERPRETER_WASM_SHA256` stays
+ *  a single constant - only the addresses and RPCs are network-scoped. */
+export const PINNED_INTERPRETER_ADDRESS_BY_NETWORK = {
+    testnet: PINNED_INTERPRETER_TESTNET_ADDRESS,
+    mainnet: PINNED_INTERPRETER_MAINNET_ADDRESS,
+};
+export const RPC_URL_BY_NETWORK = {
+    testnet: TESTNET_RPC_URL,
+    mainnet: MAINNET_RPC_URL,
+};
 /** Soroban `valid_until` window (ledgers) added to the latest ledger when
  *  building the auth entry. ~25 minutes at 5s/ledger. */
 export const DEFAULT_AUTH_VALID_UNTIL_LEDGERS = 300;
@@ -454,22 +478,34 @@ export const InstallPolicyInputSchema = z
     /** The signer that authorises the install (G... wallet). Used only for
      *  sequence number + auth nonce simulation; never persisted, never signed. */
     sourceAccount: z.string(),
+    /** Target network for the install. Selects which interpreter pin and
+     *  which RPC URL are valid by default. Defaults to `testnet` so the
+     *  pre-mainnet callers keep working: they were always pointing at
+     *  the testnet pin, so defaulting testnet here is the conservative
+     *  continuation, NOT a silent fall-through that bypasses the gate.
+     *  A caller that targets mainnet MUST set this to `mainnet` (the
+     *  pin and RPC pin do not move by themselves). */
+    network: NetworkSchema.optional(),
     /** The proposed rule draft. Mirrors the core `ContextRuleDraft` shape. */
     rule: MandateSpecSchemaForRule,
     /** Per-rule install nonce; 1 for a fresh install. */
     installNonce: z.number().int().positive(),
-    /** Optional RPC URL override. Defaults to the public testnet endpoint
-     *  (`TESTNET_RPC_URL`); the override is refused unless
+    /** Optional RPC URL override. Defaults to the pinned RPC for the
+     *  selected `network` (testnet by default, mainnet when
+     *  `network: 'mainnet'`); the override is refused unless
      *  `allowUnpinnedRpcUrl: true`, because the auth nonce and
      *  rootInvocation in the response come from whichever RPC answered. */
     rpcUrl: z.string().url().optional(),
     /** Opt-in to using a non-pinned RPC URL. Without this flag the tool
-     *  refuses any `rpcUrl` other than `TESTNET_RPC_URL` because the
-     *  caller's auth-digest binds to whatever the RPC returned. */
+     *  refuses any `rpcUrl` other than the pinned RPC for the selected
+     *  network because the caller's auth-digest binds to whatever the
+     *  RPC returned. */
     allowUnpinnedRpcUrl: z.boolean().optional(),
     /** Opt-in to pointing the rule's interpreter policy at any address
-     *  other than the pinned testnet interpreter. Default-deny: a caller
-     *  that controls the interpreter can permit everything. */
+     *  other than the pinned interpreter for the selected network.
+     *  Default-deny: a caller that controls the interpreter can permit
+     *  everything. Selecting `network: 'mainnet'` is NOT an opt-in -
+     *  the mainnet pin is its own deny-by-default anchor. */
     allowUnpinnedInterpreter: z.boolean().optional(),
     /** Base fee in stroops; defaults to BASE_FEE (100). */
     baseFee: z.number().int().positive().optional(),
@@ -486,9 +522,12 @@ export const RevokePolicyInputSchema = z
      *  verify, since the account's source is not in this repo. Proven on
      *  testnet: the account's deployer can revoke. */
     sourceAccount: z.string(),
+    /** Target network for the revoke. Same `testnet`-default as install,
+     *  so pre-mainnet callers keep working without an explicit flag. */
+    network: NetworkSchema.optional(),
     /** The rule id to remove from the smart account + interpreter. */
     ruleId: z.number().int().nonnegative(),
-    /** Optional RPC URL override; same pin as install. */
+    /** Optional RPC URL override; same per-network pin as install. */
     rpcUrl: z.string().url().optional(),
     /** Opt-in to using a non-pinned RPC URL. Same semantics as install. */
     allowUnpinnedRpcUrl: z.boolean().optional(),

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

@@ -4,7 +4,7 @@ import { getInterpreterInfo } from '../install/get-interpreter-info.ts';
 import type { SimulationResult } from '../verify/envelope.ts';
 import { type RecordTransactionInput, type SimulatePolicyInput, type SynthesizePolicyInput, type VerifyPolicyInput } from './schemas.ts';
 export type { GetInterpreterInfoInput, InstallPolicyInput, RecordTransactionInput, RevokePolicyInput, SimulatePolicyInput, SynthesizePolicyInput, VerifyPolicyInput, } from './schemas.ts';
-export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, ToolErrorSchema, VerifyPolicyInputSchema, } from './schemas.ts';
+export { ComposeUserResponsesSchema, GetInterpreterInfoInputSchema, InstallPolicyInputSchema, InterpreterOptionsSchema, MAINNET_RPC_URL, MandateSpecSchema, NetworkSchema, OraclePriceFixtureSchema, OzAdapterConfigSchema, PINNED_INTERPRETER_ADDRESS_BY_NETWORK, PINNED_INTERPRETER_GRAMMAR_VERSION, PINNED_INTERPRETER_MAINNET_ADDRESS, PINNED_INTERPRETER_TESTNET_ADDRESS, PINNED_INTERPRETER_WASM_SHA256, PredicateLeafSchema, PredicateNodeSchema, RecordedTransactionSchema, RecordTransactionInputSchema, RevokePolicyInputSchema, RPC_URL_BY_NETWORK, SimulatePolicyInputSchema, SynthesizePolicyInputSchema, TESTNET_RPC_URL, ToolErrorSchema, VerifyPolicyInputSchema, } from './schemas.ts';
 export type RunRecordTransactionInput = RecordTransactionInput;
 export type RunSynthesizePolicyInput = SynthesizePolicyInput;
 export type RunSimulatePolicyInput = SimulatePolicyInput;
@@ -59,10 +59,12 @@ export declare function runVerifyPolicy(raw: unknown): Promise<ToolResponse<true
  *  separate `interpreter.install` call is needed or possible.
  *
  *  Default-deny: an interpreter policy address other than the pinned
- *  testnet interpreter is REFUSED (the smart account would delegate to
- *  an interpreter the caller controls); the same applies to a non-pinned
- *  RPC URL (the auth nonce the wallet signs comes from the RPC). Both
- *  gates accept an explicit opt-in flag. */
+ *  interpreter for the selected network is REFUSED (the smart account
+ *  would delegate to an interpreter the caller controls); the same
+ *  applies to a non-pinned RPC URL (the auth nonce the wallet signs
+ *  comes from the RPC). Both gates accept an explicit opt-in flag.
+ *  Pin selection follows `input.network` (defaults to `testnet` so the
+ *  pre-mainnet callers keep working unchanged). */
 export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<BuildInstallPolicyResult>>;
 /** `revoke_policy` body - thin wrapper over `buildRevokePolicyXdr`.
  *  Emits an unsigned XDR for `account.remove_context_rule(ruleId)`; the
@@ -71,14 +73,23 @@ export declare function runInstallPolicy(raw: unknown): Promise<ToolResponse<Bui
  *
  *  Same RPC pin as install: a non-pinned `rpcUrl` is refused unless
  *  `allowUnpinnedRpcUrl: true`. Revoke does not carry an interpreter
- *  policy payload, so the interpreter pin is not re-checked here. */
+ *  policy payload, so the interpreter pin is not re-checked here.
+ *  Pin selection follows `input.network` (defaults to `testnet`). */
 export declare function runRevokePolicy(raw: unknown): Promise<ToolResponse<BuildRevokePolicyResult>>;
 /** `get_interpreter_info` body - thin wrapper over `getInterpreterInfo`.
  *  Returns the pinned deployment fingerprint + an optional live
  *  `grammar_version()` comparison. The audit field is deliberately
  *  OMITTED (phase-04's "audit #44" has no source of truth in the repo -
  *  fabricating it would be a lie on a security surface; the live
- *  mismatch check is worth MORE). */
+ *  mismatch check is worth MORE).
+ *
+ *  Network-aware: `input.network` selects which interpreter pin and RPC
+ *  to use. Mainnet was rolled out 2026-08-04 - the same wasm hash was
+ *  uploaded to mainnet as was exercised on testnet, so a single
+ *  `PINNED_INTERPRETER_WASM_SHA256` constant backs both networks
+ *  (DEPLOYMENTS.md:25-27). The address differs because instance ids are
+ *  network-scoped. UNAUDITED at the time of writing - see
+ *  DEPLOYMENTS.md:29-32 for what is still pending. */
 export declare function runGetInterpreterInfo(raw: unknown): Promise<ToolResponse<ReturnType<typeof getInterpreterInfo>>>;
 /** Build a canonical ToolError for a thrown exception caught by the tool
  *  envelope. The MCP SDK stringifies thrown objects as "[object Object]" by