1. it should live in this repo. If you follow https://docs.newton.xyz/developers/advanced/policy-data-oracles, we support
   typescript/python/rust. For this project, we already use typescript, so let's also use typescript for the policy data wasm as well. 2.
   let's do it as a single composite rule. 3. An off-chain indexer/service watches vault events and writes to Redis. Place the indexer
   code in this repo as well. 4. Whitelist is set as Policy Params that the NewtonPolicyClient owner (for us the vault owner) sets. Also,
   one update: in addition to Whitelist, let's ALSO have the vault owner set the max daily spending limit amount instead of strictly
   setting the max daily amount to 100 USDC at the policy level. The Max daily spend input should also be a part of policy params set by
   the owner, along with the whitelist param. Let's store this in postgres. local -
   postgres://newton:newton@localhost:5432/newton_gateway, testnet remote - postgresql://postgres:SC2vHz6B8kPuFY2.TTX-H4%5Ee20cOvS@newtoni
   ndexercommonusw2-newtonindexerdb496793b7-g3hoz4zowzv1.cluster-cnwi4m0gkxcv.us-west-2.rds.amazonaws.com:5432/newton_agent. We might need
   something like make local-dbs command like in @~/projects/newton-prover-avs/Makefile local-dbs target that launches postgres and
   redis services locally, and we would also need to create a new database named "newton_agent" for both local and remote because the
   postgres DB does not exist yet. 5. Yes, lets "REDPLOY" our contracts against stagef addresses (stagef is the default for now)
   ───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

★ Insight ─────────────────────────────────────
Key discovery: Newton's WASM data provider docs claim TypeScript support, but ALL existing examples are Rust compiled to wasm32-wasip2.
The WIT interface (newton:provider@0.1.0) defines run(input) -> result<string, string> with http.fetch() and secrets.get() imports. We'll
need to verify the TypeScript WASM compilation toolchain works with this WIT — if not, that's a newton-cli gap to track.

Stagef infrastructure is ready: PolicyFactory (0xcd2b28...), PolicyDataFactory (0x502d5d...), and PolicyClientRegistry (0x3cfef33...) are
all deployed on Base Sepolia stagef. We deploy our OWN policy + policy data through these factories — we don't reuse the sample ones.
─────────────────────────────────────────────────

Implementation Plan: Real Newton Policy for Agent NeoBank

Based on your answers and the research, here's the full plan broken into 6 workstreams:

Workstream 1: Infrastructure — Database + Docker

What: Add local Postgres + Redis via docker-compose, create newton_agent database.

┌─────────────────────────────┬──────────────────────────────────────────────────────────────────────────────────────────────────────┐
│ Task │ Detail │
├─────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Create │ Postgres 16 + Redis 7 (matches newton-prover-avs pattern) │
│ docker-compose.dev.yml │ │
├─────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Add Justfile targets │ local-dbs, local-dbs-stop, local-dbs-status, local-dbs-reset │
├─────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Update .env.example │ Add DATABASE_URL, REDIS_URL with local defaults │
├─────────────────────────────┼──────────────────────────────────────────────────────────────────────────────────────────────────────┤
│ Create DB migration │ newton_agent database with agent_spending table (agent_address, vault_address, daily_spent, │
│ │ period_start, last_tx_hash) │
└─────────────────────────────┴──────────────────────────────────────────────────────────────────────────────────────────────────────┘

Connection strings (from your answers):

• Local Redis: redis://:redis@127.0.0.1:6379
• Local Postgres: postgres://newton:newton@localhost:5432/newton_agent
• Remote Postgres: postgresql://postgres:SC2vHz6B8kPuFY2.TTX-H4%5Ee20cOvS@newtonindexercommonusw2-newtonindexerdb496793b7-g3hoz4zowzv1.cl
  uster-cnwi4m0gkxcv.us-west-2.rds.amazonaws.com:5432/newton_agent
• Remote Redis: rediss://master.newton-prover-avs-redis.ms2j0z.usw2.cache.amazonaws.com:6379

Workstream 2: Redeploy Contracts Against Stagef

What: Redeploy vault factory + vault using stagef TaskManager instead of prod.

┌───────────────────────────────┬─────────────────────────────────────────────────────────────────────────────────────┐
│ Task │ Detail │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Update .env │ NEWTON_TASK_MANAGER=0xda128a87412be6f2161bb87200f0f40e89744bd9 │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Update .env │ NEWTON_POLICY — initially use stagef sample, then swap after our policy is deployed │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Run just deploy-sepolia │ Redeploys factory proxy + vault impl against stagef TaskManager │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Deploy operator vault │ cast send $FACTORY "deployVault(...)" │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Register as PolicyClient │ newton-cli policy-client register --registry 0x3cfef33b... --client $VAULT │
├───────────────────────────────┼─────────────────────────────────────────────────────────────────────────────────────┤
│ Update deployments/84532.json │ New addresses │
└───────────────────────────────┴─────────────────────────────────────────────────────────────────────────────────────┘

Stagef addresses to use:
TaskManager: 0xda128a87412be6f2161bb87200f0f40e89744bd9
PolicyClientRegistry: 0x3cfef33b37ee120bb0522dff77ed09fd97d4b40e
PolicyFactory: 0xcd2b28eed56b51f9aee4174a9301863a9dbde60e
PolicyDataFactory: 0x502d5d784548ce8b8c2ebb1542908d8a64fd64c4

Workstream 3: Agent NeoBank Rego Policy

What: Single composite Rego rule with 3 checks, all parameterized.

policies/
agent_neobank/
agent_neobank.rego # Composite entry point
policy_params_schema.json # JSON schema for params
policy_metadata.json # Name, version, description

Policy checks (all from policy params, NOT hardcoded):

1. Token restriction — only USDC (0x036CbD53842c5426634e7929541eC2318f3dCF7e on Base Sepolia)
2. Daily spend limit — intent.value <= (max_daily_spend - daily_spent), where max_daily_spend comes from policy params and daily_spent
   from WASM data provider (Redis)
3. Receiver whitelist — intent.to must be in allowed_recipients from policy params

Policy params format (set by vault owner via newton-cli policy-client set-policy-params):
{
"84532": {
"<vault_address>": {
"agent_neobank": [
{ "name": "max_daily_spend", "type": "number", "value": 100000000, "description": "Max daily USDC spend (6 decimals)" },
{ "name": "allowed_recipients", "type": "string", "value": "0xabc...,0xdef...", "description": "Comma-separated allowed recipient
addresses" },
{ "name": "allowed_token", "type": "string", "value": "0x036CbD53842c5426634e7929541eC2318f3dCF7e", "description": "Allowed token
address (USDC)" }
]
}
}
}

Deployment via newton-cli:

1. Generate CIDs for policy files

newton-cli policy-files generate-cids --config policies/agent_neobank/policy_cids_config.json

2. Deploy PolicyData (WASM provider)

newton-cli policy-data deploy --chain-id 84532 --policy-cids policies/agent_neobank/policy_cids.json

3. Deploy Policy (Rego)

newton-cli policy deploy --chain-id 84532 --policy-data-address $POLICY_DATA --policy-cids policies/agent_neobank/policy_cids.json

4. Set policy on vault

newton-cli policy-client set-policy --chain-id 84532 --client $VAULT --policy $POLICY

5. Set policy params

newton-cli policy-client set-policy-params --chain-id 84532 --policy-client $VAULT --policy-params
policies/agent_neobank/policy_params.json --expire-after 300

Workstream 4: TypeScript WASM PolicyData Provider

What: WASM binary that reads agent spending state from Redis and returns it for Rego evaluation.

packages/policy-data/
src/
index.ts # Entry point implementing run(input) -> result<string, string>
wit/
newton-provider.wit # WIT interface (copied from newton-prover-avs)
package.json
tsconfig.json

run(input) function:

• Input: JSON string with { "policy_client": "0x...", "intent": { "from": "0x...", ... } }
• Calls secrets.get() to get Redis connection string
• Calls http.fetch() to query the indexer API for agent daily spending
• Returns: JSON string { "daily_spent": "50000000", "period_start": "2026-03-16T00:00:00Z" }

Open question: Does the Newton runtime actually support TypeScript-compiled WASM? The docs say yes, but all examples are Rust. If the
wasm32-wasip2 target from TypeScript toolchains (e.g., ComponentizeJS, jco) doesn't work with Newton's WasmExecutor, this becomes a gap.

Workstream 5: Off-Chain Indexer Service

What: Watches IntentExecuted events on-chain, writes spending data to Redis.

packages/indexer/
src/
index.ts # Service entry point
watcher.ts # Event watcher (viem watchContractEvent)
redis.ts # Redis client + spending accumulator
db.ts # PostgreSQL client for policy params storage
types.ts # Shared types
package.json
tsconfig.json

Event watched: IntentExecuted(address indexed from, address indexed to, uint256 value, bytes data)

Redis key structure:
spending:{vault}:{agent}:{YYYY-MM-DD} → cumulative USDC spent (string, 6 decimals)

PostgreSQL schema (newton_agent database):
CREATE TABLE policy_params (
vault_address TEXT NOT NULL,
chain_id INTEGER NOT NULL,
max_daily_spend BIGINT NOT NULL, -- USDC with 6 decimals
allowed_recipients TEXT[] NOT NULL, -- array of addresses
allowed_token TEXT NOT NULL DEFAULT '0x036CbD53842c5426634e7929541eC2318f3dCF7e',
updated_at TIMESTAMPTZ DEFAULT NOW(),
PRIMARY KEY (vault_address, chain_id)
);

Workstream 6: Newton CLI Gap Analysis + Linear Tasks

Identified capabilities needed:

┌─────────────────────────────────────┬────────────────────┬───────────────────────────┐
│ Capability │ newton-cli Status │ Gap? │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy deploy │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-data deploy │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-client register │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-client set-policy │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-client set-policy-params │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-files generate-cids │ Exists │ No │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ TypeScript WASM compilation │ Docs say supported │ Needs verification │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ policy-data simulate (TS) │ Rust only? │ Needs verification │
├─────────────────────────────────────┼────────────────────┼───────────────────────────┤
│ Create PostgreSQL database remotely │ Not in CLI │ Manual / migration script │
└─────────────────────────────────────┴────────────────────┴───────────────────────────┘

Execution Order

1. Infrastructure (Workstream 1) ← can start immediately
2. Redeploy contracts (Workstream 2) ← can start immediately (parallel)
3. Rego policy (Workstream 3) ← after understanding params format
4. Indexer service (Workstream 5) ← after infrastructure
5. WASM provider (Workstream 4) ← after indexer (needs API to query)
6. CLI gaps (Workstream 6) ← ongoing, Linear tasks as discovered

Deployment succeeded! All 5 steps completed (step 6 status check just needs --registry flag, non-critical).

★ Insight ─────────────────────────────────────
What just happened — the full Newton policy deployment pipeline:

1. IPFS Upload — All policy files (WASM binary, Rego policy, params schema, metadata) uploaded to IPFS via Pinata. Each got a unique CID
   (Content IDentifier).
2. PolicyData Deploy — The WASM data provider was registered on-chain at 0x6f46D7eb... via the PolicyDataFactory. Newton automatically
   set attestation info with all 13 registered attesters.
3. Policy Deploy — The Rego policy was registered on-chain at 0xEC8E048D... via the PolicyFactory, linked to the PolicyData contract.
4. Set Policy on Vault — The vault at 0x97d4DC3e... now points to this policy via setPolicyAddress().
5. Set Policy Params — Daily spend limit, allowed recipients, and allowed token configured. Got policyId: 0x972a5a03...

The vault is now fully wired to a real Newton policy. Any executeIntent() call will be evaluated against the Agent NeoBank Rego policy
with real BLS attestation.
─────────────────────────────────────────────────

Let me update the deployments file and mark NEWT-761 as Done.