Arxis Documentation

DelegationAccount (PDA)
  ├── owner          Pubkey     // wallet that created this delegation
  ├── agent          Pubkey     // AI agent wallet address
  ├── max_per_tx     u64        // lamports ceiling per transfer
  ├── daily_cap      u64        // lamports ceiling per 24h window
  ├── daily_spent    u64        // running total for current window
  ├── window_start   i64        // unix timestamp of current window
  ├── allowlist      Vec<Pubkey> // approved recipient addresses
  ├── paused         bool       // true = agent transfers blocked
  └── bump           u8         // PDA bump seed

Sets the maximum amount of SOL that can be transferred in a single transaction. The program rejects any transfer that exceeds this value, enforced at the instruction level, not the UI.

// Allow max 5 SOL per transaction
max_per_tx: 5_000_000_000  // lamports

Defines a 24-hour rolling spend window. The program tracks cumulative spending per window. Once the cap is reached, all transfers are blocked until the window resets.

Restricts the agent to a set of approved recipient addresses. Any transfer to a wallet not on the allowlist is rejected by the program. Leave empty to allow all recipients.

The program monitors spending patterns. If it detects burst spending (many transactions in a short window), a new recipient not seen before, or activity outside defined hours, it sets paused = true automatically.

create_delegation(
  max_per_tx: u64,
  daily_cap: u64,
  allowlist: Vec<Pubkey>,
) -> DelegationAccount

execute_transfer(
  amount: u64,
  recipient: Pubkey,
) -> ()   // validates all rules, then transfers

update_delegation(
  max_per_tx: Option<u64>,
  daily_cap: Option<u64>,
  allowlist: Option<Vec<Pubkey>>,
  paused: Option<bool>,
) -> DelegationAccount

import { Program, AnchorProvider } from "@coral-xyz/anchor";
import { ArxisIDL } from "./idl/arxis";

const PROGRAM_ID = new PublicKey("PROGRAM_ID_HERE");

const provider = new AnchorProvider(connection, wallet, {});
const program = new Program(ArxisIDL, PROGRAM_ID, provider);

// Create a delegation
await program.methods
  .createDelegation(
    new BN(5_000_000_000),  // max_per_tx: 5 SOL
    new BN(50_000_000_000), // daily_cap: 50 SOL
    [new PublicKey("RECIPIENT_PUBKEY")]
  )
  .accounts({ owner: wallet.publicKey })
  .rpc();

// Agent executes a transfer
await program.methods
  .executeTransfer(new BN(1_000_000_000)) // 1 SOL
  .accounts({
    delegation: delegationPda,
    agent: agentKeypair.publicKey,
    recipient: recipientPubkey,
  })
  .signers([agentKeypair])
  .rpc();

import { createWalletClient, http, parseEther } from "viem";
import { mainnet } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";

const ARXIS_CONTRACT = "CONTRACT_ADDRESS_HERE"; // set after deploy

const agent = privateKeyToAccount(AGENT_PRIVATE_KEY);
const client = createWalletClient({
  account: agent,
  chain: mainnet,
  transport: http(),
});

// Execute a transfer through Arxis guardrails
await client.writeContract({
  address: ARXIS_CONTRACT,
  abi: arxisAbi,
  functionName: "executeTransfer",
  args: [
    recipientAddress,
    parseEther("0.5"), // 0.5 ETH
  ],
});

// SPDX-License-Identifier: MIT
interface IArxis {
    function createDelegation(
        address agent,
        uint256 maxPerTx,
        uint256 dailyCap,
        address[] calldata allowlist
    ) external;

    function executeTransfer(
        address recipient,
        uint256 amount
    ) external;

    function pauseDelegation() external;
    function resumeDelegation() external;
}