SDK Documentation

npm install @loopprotocol/sdk-byoaa @loopprotocol/sdk
export LOOP_API_KEY="loop_byoaa_dev_..."

import { LoopByoaaClient } from "@loopprotocol/sdk-byoaa";

const loop = new LoopByoaaClient({
  apiKey: process.env.LOOP_API_KEY!,
  // dev SDK keys resolve to https://dev-api.kya.looplocal.io
});

const agent = await loop.agents.register({
  external_id: "first-agent",
  display_name: "First Agent",
  purpose: "First 200 quickstart",
  risk_tier: "low",
});

await loop.permissions.grant({
  agent_id: agent.id,
  on_behalf_of_user_id: "user_demo",
  layer: "shopping",
  action_class: "purchase",
  amount_cap_cents: 2500,
});

const decision = await loop.decisions.request({
  agent_id: agent.id,
  on_behalf_of_user_id: "user_demo",
  intended_action: {
    layer: "shopping",
    action_class: "purchase",
    amount_cents: 1250,
    target: { merchant_name: "Loop Demo Merchant" },
  },
});

console.log("first allow/review/deny decision", decision.outcome);

import { LoopByoaaClient } from "@loopprotocol/sdk-byoaa";

const loop = new LoopByoaaClient({
  apiKey: process.env.LOOP_BYOAA_API_KEY!, // dev keys route to https://dev-api.kya.looplocal.io by default
});

const agent = await loop.agents.register({
  external_id: "friend-test-agent",
  display_name: "Friend Test Agent",
  purpose: "Dev adopter integration test",
  risk_tier: "low",
});

await loop.permissions.grant({
  agent_id: agent.id,
  on_behalf_of_user_id: "user_123",
  layer: "shopping",
  action_class: "purchase",
  amount_cap_cents: 2500,
});

const decision = await loop.decisions.request({
  agent_id: agent.id,
  on_behalf_of_user_id: "user_123",
  intended_action: {
    layer: "shopping",
    action_class: "purchase",
    amount_cents: 1250,
    target: { merchant_name: "Loop Demo Merchant" },
  },
});

const pack = await loop.audit.exportPack({
  range: { from: new Date(Date.now() - 86_400_000), to: new Date() },
  format: "json",
});
console.log(decision.outcome, pack.manifest);

import { Connection } from "@solana/web3.js";
import { Loop } from "@loopprotocol/sdk";

const connection = new Connection("https://api.devnet.solana.com", "confirmed");
const loop = new Loop({ connection });

// Optional: quorum reads across a second RPC provider
const loopWithQuorum = new Loop({
  connection,
  rpcs: [new Connection("https://your-second-rpc-provider.example.com")],
});

// Initialize a vault — returns a TransactionInstruction to sign and send
const initIx = await loop.vault.initializeVault(owner);

// Fetch vault state (null if the vault doesn't exist yet)
const vault = await loop.vault.getVault(owner);

// Or just check existence
const hasVault = await loop.vault.exists(owner);

// Derive the vault PDA directly
const [vaultAddress] = loop.vault.getVaultAddress(owner);

import { BN } from "@coral-xyz/anchor";

// Wrap USDC → Cred
const wrapIx = await loop.cred.wrap(
  user,                 // signer
  new BN(100_000_000),  // 100 USDC
  userUsdcAccount,
  userCredAccount,
  credMint,
  reserveVault
);

// Unwrap Cred → USDC
const unwrapIx = await loop.cred.unwrap(
  user,
  new BN(50_000_000),   // 50 Cred
  userCredAccount,
  userUsdcAccount,
  credMint,
  reserveVault
);

// Read reserve backing status
const reserve = await loop.cred.getReserveStatus(reserveVault, credMint);

import { BN } from "@coral-xyz/anchor";

// Stack with a lock period — the nonce distinguishes stacks in one vault
const stackNonce = new BN(Date.now());
const stackIx = await loop.vault.stack(
  owner,
  new BN(1_000_000_000), // 1000 Cred
  90,                    // 90-day lock
  stackNonce
);

// Derive the stack record address for later operations
const [vaultAddress] = loop.vault.getVaultAddress(owner);
const [stackAddress] = loop.vault.getStackAddress(vaultAddress, stackNonce);

// Unstack after the lock expires
const unstackIx = await loop.vault.unstack(owner, stackAddress);

// Claim accrued yield on a stack
const claimIx = await loop.vault.claimYield(owner, stackAddress);

// Register a personal agent bound to its principal
const registerIx = await loop.avp.registerPersonalAgent(
  agentPublicKey,
  principalHash, // 32-byte hash binding the agent to its principal
  "https://example.com/agent-metadata.json"
);

// Register a service agent (creator holds OXO stake)
const serviceIx = await loop.avp.registerServiceAgent(
  creator,
  agentPublicKey,
  "https://example.com/service-metadata.json",
  creatorOxoAccount
);

// Declare capabilities
const capabilitiesIx = await loop.avp.declareCapabilities(agentPublicKey, [
  loop.avp.createCapabilityId("shopping"),
  loop.avp.createCapabilityId("transfer"),
]);

// Read agent identity (null if not registered)
const identity = await loop.avp.getAgent(agentPublicKey);
const registered = await loop.avp.isRegistered(agentPublicKey);