Symbion Documentation

import { ethers } from 'ethers';

const CONTRACT = '';
const ABI = [/* see Full ABI section below */];

// Connect wallet (MetaMask / any EIP-1193 provider)
const provider = new ethers.providers.Web3Provider(window.ethereum);
await provider.send('eth_requestAccounts', []);
const signer   = provider.getSigner();
const contract = new ethers.Contract(CONTRACT, ABI, signer);

// Upload metadata to IPFS first, then mint
const metadataURI = 'ipfs://QmYour...MetadataHash';

const tx = await contract.mintAgent(metadataURI, {
  value: ethers.utils.parseEther('0.01'),  // 0.01 BNB mint fee
});

const receipt = await tx.wait();
console.log('Agent minted! TX:', tx.hash);
// tokenId is emitted in the AgentMinted event

{
  "name":        "QuantumYield-Alpha",
  "description": "Symbion AI Agent: Maximize yield via PancakeSwap auto-compound",
  "image":       "ipfs://QmYourImageHash",   // IPFS image URI
  "attributes": [
    { "trait_type": "Risk Level",  "value": 5         },
    { "trait_type": "Protocols",   "value": "PancakeSwap, Venus" },
    { "trait_type": "Status",      "value": "Active"  },
    { "trait_type": "Platform",    "value": "Symbion Web4" }
  ],
  "aiPrompt":        "Maximize yield by auto-compounding on PancakeSwap...",
  "riskLevel":       5,               // 1-10
  "targetProtocols": ["PancakeSwap", "Venus"],
  "agentColor":      "#00F0FF",       // hex color for UI
  "createdAt":       1720000000000    // Unix ms
}

// Read agents owned by a wallet
const balance = await contract.balanceOf(userAddress);

const tokenIds = await Promise.all(
  Array.from({ length: Number(balance) }, (_, i) =>
    contract.tokenOfOwnerByIndex(userAddress, i)
  )
);

// Fetch metadata for each token
const agents = await Promise.all(tokenIds.map(async tokenId => {
  const uri      = await contract.tokenURI(tokenId);
  const isActive = await contract.getAgentStatus(tokenId);
  const meta     = await fetch(ipfsToHttp(uri)).then(r => r.json());
  return { tokenId, uri, isActive, meta };
}));

// Toggle agent activation
const tx = await contract.toggleAgent(tokenId);
await tx.wait(); // wait for BSC confirmation

// List agent on marketplace
const priceWei = ethers.utils.parseEther('0.5');
const tx2 = await contract.listAgent(tokenId, priceWei);
await tx2.wait();

// Get all listings
const listings = await contract.getListedAgents();
// listings = [{ tokenId, seller, price, tokenURI }, ...]

// Buy a specific listing
const listing = listings[0];
const tx = await contract.buyAgent(listing.tokenId, {
  value: listing.price,  // exact BNB amount required
});
await tx.wait();
console.log('Purchase complete!', tx.hash);

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/// @title ISymbionProtocol
/// @notice Implement this interface to integrate a DeFi protocol with Symbion AI Agents
interface ISymbionProtocol {
    /// @notice Called when an AI Agent executes a strategy step
    /// @param agentId The NFT tokenId of the executing agent
    /// @param params  ABI-encoded strategy parameters (protocol-specific)
    /// @return success Whether the execution succeeded
    /// @return yield   Amount of yield generated (in protocol base token wei)
    function executeStrategy(
        uint256 agentId,
        bytes calldata params
    ) external returns (bool success, uint256 yield);

    /// @notice Returns current protocol health metrics
    /// @return tvl       Total value locked in wei
    /// @return apr       Annual percentage rate (basis points, 100 = 1%)
    /// @return isActive  Whether the protocol is currently operational
    function getProtocolMetrics() external view returns (
        uint256 tvl,
        uint256 apr,
        bool    isActive
    );

    /// @notice Human-readable protocol name
    function protocolName() external view returns (string memory);
}

/// @title Example: Integrating a custom DEX
contract MyDEXIntegration is ISymbionProtocol {
    address public immutable router;
    string  public override protocolName = "MyDEX";

    constructor(address _router) { router = _router; }

    function executeStrategy(uint256 agentId, bytes calldata params)
        external override returns (bool, uint256)
    {
        (address tokenIn, address tokenOut, uint256 amount) =
            abi.decode(params, (address, address, uint256));
        // Execute swap on your DEX...
        return (true, 0);
    }

    function getProtocolMetrics() external view override returns (uint256, uint256, bool) {
        return (1_000_000 ether, 1500, true); // $1M TVL, 15% APR
    }
}