Veyla Protocol Docs

// XCM Precompile address on Polkadot Hub
address constant XCM_PRECOMPILE = 0x00000000000000000000000000000000000a0000;

interface IXcm {
    struct Weight { uint64 refTime; uint64 proofSize; }

    // Execute an XCM message locally (same chain context)
    function execute(bytes calldata message, Weight calldata weight) external;

    // Send an XCM message to another parachain or chain
    function send(bytes calldata destination, bytes calldata message) external;

    // Estimate execution weight for a given XCM message
    function weighMessage(bytes calldata message) external view returns (Weight memory);
}

// Yield formula (per-block accrual):
// pending = principal × apyBps × elapsed / (365 days × 10_000)

function earned(address user, address token) external view returns (uint256) {
    return _accruedYield[user][token] + _pendingYield(user, token);
}

// _accrueYield() is called before every deposit/withdraw to snapshot pending yield
// This prevents dilution when new deposits are made mid-period
function _accrueYield(address user, address token) internal {
    _accruedYield[user][token] += _pendingYield(user, token);
    _depositTimestamps[user][token] = block.timestamp;
}

// XCM Precompile — Polkadot Hub native (0x...000a0000)
interface IXcm {
    struct Weight { uint64 refTime; uint64 proofSize; }

    // Execute XCM locally with caller's origin
    function execute(bytes calldata message, Weight calldata weight) external;

    // Send XCM to another parachain
    function send(bytes calldata destination, bytes calldata message) external;

    // Estimate weight for execution
    function weighMessage(bytes calldata message) external view returns (Weight memory);
}

// pallet-assets ERC-20 Precompile — native USDT (Asset ID 1984)
interface IERC20Precompile {
    function transfer(address to, uint256 value) external returns (bool);
    function transferFrom(address from, address to, uint256 value) external returns (bool);
    function approve(address spender, uint256 value) external returns (bool);
    function balanceOf(address account) external view returns (uint256);
    function allowance(address owner, address spender) external view returns (uint256);
}

Yield Formula:
  pending = principal × APY_bps × elapsed_seconds / (365 days × 10,000)

Example (DOT @ 14.20% APY):
  1 DOT deposited → after 30 days:
  pending = 1e18 × 1420 × 2,592,000 / (31,536,000 × 10,000)
  pending = 0.01167 DOT ≈ 0.0117 DOT

Withdrawal Payout:
  totalPayout = principal + earnedYield - protocolFee
  protocolFee = earnedYield × protocolFeeBps / 10,000  (default 0.5%)

Safety Cap:
  actualYield = min(earnedYield, yieldPoolBalance)
  → Principal is NEVER locked, even if yield pool is empty
  → Unclaimed yield persists in _accruedYield for future claimYield() calls

DOT deposit:
  idle → awaiting-signature → pending → success
                 ▲ (MetaMask: approve sending PAS/DOT native)

USDT deposit:
  idle → awaiting-approval → approving → awaiting-signature → pending → success
              ▲ (approve TX)                  ▲ (deposit TX)

Withdrawal (DOT or USDT):
  idle → awaiting-signature → pending → success

// Deposit DOT (native) or USDT into the vault.
// For DOT:  send msg.value, set token = address(0), amount is ignored.
// For USDT: approve vault first, set token = USDT precompile address, amount = wei.
function deposit(address token, uint256 amount) external payable;

// Withdraw deposited principal + available yield back to caller.
// Principal is always returnable even if yield pool is empty.
function withdraw(address token, uint256 amount) external;

// Harvest accrued yield without closing the position.
function claimYield(address token) external;

// [Owner only] Execute an XCM message locally via precompile.
function routeAssets(address token, bytes calldata xcmMessage) external;

// [Owner only] Send XCM cross-chain to target parachain.
function sendCrossChain(address token, bytes calldata destination, bytes calldata xcmMessage) external;

// [Owner only] Update APY for an asset (basis points, capped at 10_000 = 100%).
function setApy(address token, uint256 apyBps) external;

// [Owner only] Pause or unpause deposits and withdrawals.
function setPaused(bool _paused) external;

// [Owner only] Seed the yield pool (called by owner or via XCM receive()).
function fundYieldPool() external payable;

// [Owner only] Step 1 of 2-step ownership transfer — nominate new owner.
function transferOwnership(address newOwner) external;

// [Pending owner only] Step 2 — accept and finalise ownership transfer.
function acceptOwnership() external;

// [Owner only] Step 1 of 2-step treasury (fee recipient) transfer.
function proposeTreasury(address newTreasury) external;

// [Pending treasury only] Step 2 — accept and activate new treasury address.
function acceptTreasury() external;

// [Owner only] Whitelist a cross-chain XCM destination (raw bytes encoding).
function addTrustedDestination(bytes calldata destination) external;

// [Owner only] Remove a previously whitelisted XCM destination.
function removeTrustedDestination(bytes calldata destination) external;

// [Owner only] Update protocol fee (basis points, capped at MAX_FEE_BPS).
function setProtocolFee(uint256 feeBps) external;

// [Owner only] Update the minimum rebalance interval in seconds.
function setRebalanceInterval(uint256 interval) external;

// [Owner only] Update the human-readable route label for a token.
function setTokenRoute(address token, string calldata route) external;

// User's deposited principal for a given token.
function balanceOf(address user, address token) external view returns (uint256);

// User's total earned yield (snapshotted + pending since last deposit).
function earned(address user, address token) external view returns (uint256);

// Current APY for a token, in basis points (divide by 100 for %).
function currentApy(address token) external view returns (uint256);

// Total combined TVL across all assets (raw units).
function tvl() external view returns (uint256);

// TVL for a specific token.
function tvlOf(address token) external view returns (uint256);

// Timestamp of the user's last deposit for a given token.
function depositTimestampOf(address user, address token) external view returns (uint256);

// Human-readable route label for a token (e.g. "Hydration").
function tokenRoute(address token) external view returns (string memory);

// Public state
address public owner;
address public pendingOwner;
address public treasury;
address public pendingTreasury;
bool public paused;

event Deposited(address indexed user, address indexed token, uint256 amount);
event Withdrawn(address indexed user, address indexed token, uint256 amount);
event YieldClaimed(address indexed user, address indexed token, uint256 amount);
event RoutedLocally(address indexed token, uint256 amount);
event RoutedCrossChain(address indexed token, bytes destination, uint256 amount);
event YieldPoolFunded(address indexed from, uint256 amount);
event ApyUpdated(address indexed token, uint256 newApyBps);
event Paused(bool isPaused);
event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event TreasuryProposed(address indexed newTreasury);
event TreasuryUpdated(address indexed newTreasury);
event TrustedDestinationAdded(bytes destination);
event TrustedDestinationRemoved(bytes destination);
event ProtocolFeeUpdated(uint256 newFeeBps);
event RebalanceIntervalUpdated(uint256 newInterval);
event TokenRouteUpdated(address indexed token, string route);