Skip to main content
YieldPoint deploys on Base (hub) and two spoke chains (Avalanche and Katana). Contract state lives on the hub; spoke chains hold tokens and interact with the hub via LayerZero messages. This page lists the deployed addresses for each chain, then walks through the contract architecture: layer organization, vault inheritance, the LayerZero integration, and a reference table of the key contracts.

​
Deployed addresses

The UTY contract on both Avalanche and Katana uses the same address as UTY on Base. Similarly for yUTY. This is intentional — YieldPoint used CREATE3 to produce identical addresses across EVM chains for contracts deployed with the same deployer and salt, so you can hard-code one address per token and route by chain ID.

​
Base (hub)

  • Chain ID: 8453
  • LayerZero EID: 30184
Base is the hub chain — all vault state, share price, and withdrawal queue management lives here. UTY is minted and redeemed directly on Base; cross-chain UTY operations go through the adapter. yUTY is minted and redeemed on Base (either directly or via cross-chain composer calls from spokes).

​
Avalanche (spoke)

  • Chain ID: 43114
  • LayerZero EID: 30106

​
Avalanche flat fees

Fees are charged by the spoke yUTY VaultInterface on cross-chain deposit and redeem calls. They cover the per-message LayerZero gas cost for spoke-to-hub and hub-to-spoke routing. The fees are held as token balances in the VaultInterface contract and swept periodically by the operations role.

​
Katana (spoke)

  • Chain ID: 747474
  • LayerZero EID: 30375

​
Katana flat fees

Fees are charged by the spoke yUTY VaultInterface on cross-chain deposit and redeem calls, same pattern as Avalanche. Addresses sourced from the YieldPoint contracts repo at commit 730f599e on 2026-04-07. Re-sync when the contracts repo deploys new addresses.

​
Architectural layers

The YieldPoint contracts are organized into four architectural layers plus a LayerZero integration column. Each layer depends on the layer below it: Examples extend Extensions, which extend Core, which implements Interfaces. The LayerZero column sits in parallel with its own internal structure.
Examples (deployable)
UTY
yUTY
Extensions (mixins)
UTYAsyncVaultV1Custodian
UTYAsyncVaultV1Instant
UTYAsyncVaultV1Ethena
ERC20AuthorizationUpgradeable
PausableWithPauserAuth
Core (abstract base)
UTYAsyncVaultV1
LayerZero integration
ShareOFTAdapter
UTYVaultComposer
OFTExtended
UTYVaultInterface
The layers are listed in dependency order — top to bottom matches the dependency direction. Test mocks are not part of the runtime dependency graph and are omitted from this view.

​
Vault inheritance

​
UTYAsyncVaultV1 (abstract base)

The base vault inherits from seven upgradeable OpenZeppelin and YieldPoint contracts:
  • ERC4626Upgradeable
  • ERC20AuthorizationUpgradeable (EIP-3009)
  • Ownable2StepUpgradeable
  • AccessControlEnumerableUpgradeable
  • UUPSUpgradeable
  • ReentrancyGuardUpgradeable
  • PausableUpgradeable

​
UTY vault configuration

UTY extends UTYAsyncVaultV1 with two extensions plus an override:
  • UTYAsyncVaultV1Custodian — adds the custodian sweep, totalManagedAssets tracking, totalAssets() override, and emergency write-down via reduceTotalManagedAssets()
  • UTYAsyncVaultV1Instant — adds the instant redemption path below a configurable threshold
  • donate() is overridden to revert
Why donate() reverts for UTY. The UTY vault maintains a strict 1:1 peg with USDC. In a standard ERC-4626 vault, anyone can call donate() to add assets without minting shares, which increases the exchange rate for all shareholders. For UTY, this would break the 1:1 guarantee — if someone donated 1000 USDC, existing UTY holders would suddenly have shares worth more than 1 USDC each. By reverting on donate(), the UTY vault ensures the exchange rate can never deviate from 1.0. This is intentional and critical to UTY’s design as a stablecoin, not a yield-bearing token. (The yUTY vault, by contrast, allows donations — this increases the exchange rate for existing shareholders, which is the desired behavior for a yield vault.)

​
yUTY vault configuration

yUTY extends UTYAsyncVaultV1 directly, without the custodian or instant extensions:
  • Async ERC-7540 vault without the UTYAsyncVaultV1Instant extension
  • 18-decimal shares (no decimals offset; inflation defense via seed deposit)

​
LayerZero contracts

The LayerZero integration layer splits between hub-side and spoke-side contracts.

​
Hub-side (Base)

  • ShareOFTAdapter — OFT adapter wrapping the vault’s share token. Uses the lockbox model: tokens sent cross-chain are locked in the adapter, not burned. Inherits PausableWithPauserAuth for bridge-level pause control.
  • UTYVaultComposer — handles incoming cross-chain lzCompose messages, executes vault operations on behalf of the caller, and manages refund recovery for failed composes. Extends VaultComposerSyncPatched (the YieldPoint patched version of the LayerZero base composer) and Ownable2Step.

​
Spoke-side (Avalanche, Katana)

  • OFTExtended — the UTY and yUTY token representation on spoke chains. Mint/burn model: tokens arriving from the hub are minted, tokens leaving are burned. Extends OFTUpgradeable, ERC20AuthorizationUpgradeable, and Ownable2StepUpgradeable.
  • UTYVaultInterface — the spoke-chain proxy that makes yUTY deposits and redemptions feel local to a user on Avalanche or Katana. Charges flat fees on cross-chain calls (see Tokens and fees). Uses AccessControl, ERC-7201 namespaced storage, and maintains a per-user pending-claims counter that prevents double-spending of claim credits.

​
Key contracts

​
Example contracts

YieldPoint ships two concrete vault implementations ready for deployment: Both contracts hardcode their names and symbols. Bonding period, deposit caps, and other parameters are configured per vault after deployment.