nTBILL Integration

nTBILL is the Nest Treasury Vault. This page is organized around the recommended Actions API path first, then the direct contract path for advanced EVM integrations, plus the Solana transaction-builder flow.

Outline

• Quick reference
• Supported assets
• EVM Integration:
  • Actions API (recommended)
  • Direct onchain
• Solana Integration
• Errors and edge cases
• Implementation notes

Quick reference

Field	Value
Vault	Nest Treasury Vault
Symbol	nTBILL
Slug	nest-treasury-vault
EVM share token	0xe72fe64840f4ef80e3ec73a1c749491b5c938cb9
Share decimals	6
EVM Actions API base URL	https://api.nest.credit/v1/actions
Solana API base URL	https://api.nest.credit/v1/solana
Solana share mint	2sA2jW9e8EYJkLFpq9hkhxfVUQBwVGJwq6iP4TmTKrL4
Solana USDC mint	EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

Supported assets

EVM

Chain	Deposit or redemption asset	nTBILL NestVault	Decimals
Plume98866	USDC0x2223…a7af	0x250c…7f12	6
Plume98866	pUSD0xdddd…6f3f	0xd263…baed	6
Ethereum1	USDC0xa0b8…eb48	0x250c…7f12	6

Solana

Field	Value
nTBILL SPL mint	2sA2jW…KrL4
OFT program ID	ChEfPd…j1th
OFT config key	5B25A3…rRSL
Solana USDC mint	EPjFWd…Dt1v
Plume NestVaultComposer for nTBILL	0x719e…d873

EVM Integration

Actions API (recommended)

Use the EVM Actions API when your app wants Nest to handle quote construction, vault selection, Predicate compliance checks, calldata encoding, and transaction simulation for nTBILL. The API returns transactions that your app signs and sends with the user’s EVM wallet.

This section covers:

• Mint quote
• Build mint transactions
• Redeem quote
• Build redemption transactions
• Pending, update, and claim
• Instant redemption

The base URL is:

https://api.nest.credit/v1/actions

All amounts are raw base-unit integer strings. Do not send decimal UI amounts.

Mint quote

Use the quote route before building transactions. This returns the expected raw share amount, decimals, fee fields, rate fields, and a preview of the transaction steps.

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/mint/quote \
  -H 'content-type: application/json' \
  -d '{
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "chainId": 98866
  }'

Example response shape:

{
  "data": {
    "slug": "nest-treasury-vault",
    "shareTokenAddress": "0xe72fe64840f4ef80e3ec73a1c749491b5c938cb9",
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "depositDecimals": 6,
    "shareAmount": "...",
    "shareDecimals": 6,
    "rate": "...",
    "rateDecimals": 6,
    "feeAmount": "0",
    "fees": {
      "ratePpm": 0,
      "flatAmount": "0",
      "maxRatePpm": 0,
      "maxFlatAmount": "0"
    },
    "steps": [
      { "label": "approve", "description": "Approve PredicateProxy to spend the deposit asset" },
      { "label": "deposit", "description": "Deposit through NestVaultPredicateProxy" }
    ]
  }
}

steps is a preview. The actual build-tx response may omit approve if the wallet already has sufficient allowance.

Build mint transactions

Use build-tx when the user is ready to deposit. The recipient is the EVM address that signs as depositor and receives the minted nTBILL shares.

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/mint/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "depositAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "depositAmount": "1000000",
    "chainId": 98866,
    "recipient": "0x00000000000000000000000000000000000000ab"
  }'

Submit the returned transactions in order. Every returned transaction uses the chain ID from the request. By default, the API simulates the transaction bundle before returning it. User-facing apps should generally keep simulation enabled.

Redeem quote

Use the redeem quote route before submitting a redemption. This quotes the redemption asset amount and validates the selected asset for this vault.

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/redeem/quote \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "shareAmount": "1000000",
    "chainId": 98866
  }'

For this guide, treat the NestVault redemption flow as the supported redemption path. If an integration receives an unsupported route value, surface it as an integration error instead of trying to fall back to a different contract flow.

Build redemption transactions

Use this route to submit a redemption request on the same EVM chain.

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/redeem/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "shareAmount": "1000000",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

NestVault redemptions return:

• approve, if the selected NestVault does not already have sufficient share-token allowance.
• requestRedeem, to submit the asynchronous redemption request.

After the request becomes claimable, use the claim routes below.

Pending, update, and claim

For NestVault-backed redemptions:

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/claim/pending \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

curl -X POST https://api.nest.credit/v1/actions/vaults/nest-treasury-vault/claim/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "redemptionAsset": "0x222365ef19f7947e5484218551b56bb3965aa7af",
    "chainId": 98866,
    "user": "0x00000000000000000000000000000000000000ab"
  }'

claim/build-tx builds a transaction to claim all currently claimable shares for the selected NestVault and user.

The update routes are for reducing an existing pending redemption:

POST /vaults/nest-treasury-vault/update-redeem/pending
POST /vaults/nest-treasury-vault/update-redeem/build-tx

newShareAmount is the final pending share amount, not the delta to remove.

Instant redemption

When instant liquidity is available for the selected asset, use:

POST /vaults/nest-treasury-vault/instant-redeem/quote
POST /vaults/nest-treasury-vault/instant-redeem/liquidity
POST /vaults/nest-treasury-vault/instant-redeem/build-tx

The instant-redeem request body uses redemptionAsset, shareAmount, chainId, and user. receiver is optional and defaults to user.

Direct onchain

Use direct contracts only when your integration needs lower-level control than the Actions API provides. This path requires you to handle the full flow yourself:

This section covers:

• Main contracts
• Direct mint outline
• Direct redeem outline

For a direct integration, you handle:

• Validate the selected chain, vault slug, and asset.
• Check Predicate compliance and obtain a valid Predicate message.
• Read the correct NestVault for the asset.
• Quote shares or redemption assets.
• Apply any app-level slippage or UX checks.
• Submit ERC-20 approvals.
• Submit deposit, redeem, update, instant-redeem, or claim calls.
• Track asynchronous redemption state.

Main nTBILL contracts

Contract	Address
nTBILL share token	0xe72f…8cb9
NestVaultPredicateProxy	0xfc0c…9035
USDC NestVault (Plume, Ethereum)	0x250c…7f12
pUSD NestVault (Plume)	0xd263…baed

For accountants, roles, and other shared protocol contracts, use the Smart Contracts page as the source of truth.

Direct mint outline

For nTBILL minting, the direct flow is:

1. Read the NestVault for the selected deposit asset and chain.
2. Call previewDeposit(depositAmount) on that NestVault to estimate shares after fees.
3. Get a Predicate message for the user and chain.
4. Approve NestVaultPredicateProxy to spend the deposit asset.
5. Call NestVaultPredicateProxy.deposit(depositAsset, depositAmount, recipient, nestVault, predicateMessage).

Minimal TypeScript outline:

import { encodeFunctionData, parseUnits } from "viem";

const chainId = 98866;
const recipient = "0x00000000000000000000000000000000000000ab";
const depositAsset = "0x222365ef19f7947e5484218551b56bb3965aa7af";
const depositAmount = parseUnits("1", 6);
const nestVault = "0x250c2d14ed6376fb392fba1edd2cfd11d2bf7f12";
const predicateProxy = "0xfc0c4222b3a0c9b060c0b959dec62442036b9035";

// 1. previewDeposit on nestVault
// 2. get Predicate message for recipient
// 3. approve depositAsset -> predicateProxy
// 4. encode PredicateProxy deposit call
const data = encodeFunctionData({
  abi: NestVaultPredicateProxyAbi,
  functionName: "deposit",
  args: [depositAsset, depositAmount, recipient, nestVault, predicateMessage],
});

The Actions API’s mint/build-tx route performs these steps for app integrations and is the preferred reference for expected calldata shape.

Direct redeem outline

For nTBILL redemptions, use the selected NestVault for the redemption asset:

1. Approve the NestVault to spend nTBILL shares, if allowance is insufficient.
2. Call NestVault.requestRedeem(shareAmount, user, user).
3. Wait until shares become claimable.
4. Call NestVault.redeem(claimableShares, user, user) to claim the redemption asset.

If you need to reduce a pending redemption before it is claimable, call NestVault.updateRedeem(newShareAmount, user, user).

Solana Integration

Use the Solana transaction-builder endpoints or the browser SDK. The API returns a base64-encoded Solana VersionedTransaction; the user’s wallet signs and broadcasts it.

At a high level, Solana integrations are transaction-builder flows. Call a build-tx endpoint to get the transaction for a mint or redemption, have the user wallet sign it, and broadcast it on Solana.

Mints settle asynchronously: after the mint transaction is submitted, the Nest token is minted to the receiver’s Solana wallet, typically in about one minute at default priority. Standard redemptions are also asynchronous and settle according to the vault asset’s redemption policy and cadence. After the user submits the Solana redemption request, Nest keeper automation handles the follow-up redeem and auto-claim steps once liquidity is ready. USDC is returned to the user’s Solana wallet automatically; the user does not build or sign a later finish, claim, or finalize transaction. If instant liquidity is available, the Solana redeem endpoint can build an instant-redemption transaction for a fee.

This section covers:

• Build Solana mint transaction
• Build Solana standard redemption (async) transactions
• Track Solana redemption status
• Build Solana instant redeem transaction
• Sponsored fee payer support
• Browser SDK pattern

The base URL is:

https://api.nest.credit/v1/solana

Solana transaction builders support both user-paid and sponsored fee-payer transactions. If feePayer is omitted, behavior is unchanged: the user wallet pays Solana transaction fees. If feePayer is provided, it must be a base58 Solana public key and becomes static account key 0, the transaction fee payer.

The user wallet remains the token owner or authority and must still sign. In sponsored mode, the user wallet should pay 0 SOL; the sponsor or relayer signs the fee-payer slot and broadcasts the transaction.

Flow	Amount field	Type
Mint	rawAmountUsdc	number
Standard redemption (async) request	rawAmountNestToken	string
Standard redemption (async) update/cancel	newRawAmountNestToken	string
Instant redeem	rawAmountNestToken	number

Build Solana mint transaction

curl -X POST https://api.nest.credit/v1/solana/nest/mint/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "rawAmountUsdc": 1000000,
    "finality": "standard",
    "nestVaultSlug": "nest-treasury-vault",
    "receiver": "CFagSTMBFiMaD4YKHr7mMcKTzpi35DqiBKbDA35BvZgr"
  }'

Response shape:

{
  "data": {
    "txBase64": "..."
  }
}

The returned transaction:

• Deposits Solana USDC through CCTP.
• Routes to Plume for the nTBILL mint.
• Delivers nTBILL back to the receiver as an SPL token through LayerZero OFT.
• Is pre-signed where needed by Nest keeper infrastructure.
• Still requires the receiver wallet signature before broadcast.

finality can be standard or fast. fast uses the 1 bp CCTP fast-finality fee and is expected to settle faster.

Sponsored mint request body:

{
  "nestVaultSlug": "nest-treasury-vault",
  "rawAmountUsdc": 1000000,
  "receiver": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>",
  "finality": "fast"
}

Build Solana standard redemption (async) transactions

Use standard redemption (async) when a Solana user wants to request a redemption, then later update or cancel the pending request before it is processed. The user’s only required Solana action is to sign and broadcast the request or update transaction. After liquidity is ready, Nest keeper automation completes the redeem and auto-claim flow, and USDC is returned automatically. The user does not submit a separate finish, claim, or finalize transaction.

Sponsored standard redemption (async) request body:

{
  "nestVaultSlug": "nest-treasury-vault",
  "rawAmountNestToken": "1000000",
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

Submit that body to POST https://api.nest.credit/v1/solana/nest/async-redeem/request/build-tx.

Sponsored standard redemption (async) cancel/update-to-zero request body:

{
  "nestVaultSlug": "nest-treasury-vault",
  "newRawAmountNestToken": "0",
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

Submit that body to POST https://api.nest.credit/v1/solana/nest/async-redeem/update/build-tx. Both standard redemption builders return the same txBase64 response shape as mint and instant redeem.

Track Solana redemption status

After broadcasting the user’s Solana redemption transaction, track the flow with the original Solana transaction signature:

curl https://api.nest.credit/v1/solana/redeem-status/<SOLANA_REDEEM_TX_SIGNATURE>

The status response includes the cross-chain stages:

• solanaBurn: the user’s Solana request transaction.
• plumeProcessing: delivery and processing on Plume.
• cctpAttestation: USDC return path attestation.
• solanaClaim: keeper-driven auto-claim delivery back to the user’s Solana wallet.

solanaClaim is a lifecycle stage, not a user action. Apps should show it as automatic settlement progress instead of asking the user to build or sign a separate claim transaction.

Build Solana instant redeem transaction

curl -X POST https://api.nest.credit/v1/solana/nest/redeem/build-tx \
  -H 'content-type: application/json' \
  -d '{
    "rawAmountNestToken": 1000000,
    "nestVaultSlug": "nest-treasury-vault",
    "owner": "CFagSTMBFiMaD4YKHr7mMcKTzpi35DqiBKbDA35BvZgr"
  }'

Response shape:

{
  "data": {
    "txBase64": "..."
  }
}

The Solana redeem builder sends nTBILL SPL shares through the OFT path to the nTBILL composer on Plume. The Plume-side flow processes redemption and returns USDC through CCTP.

From the user’s perspective, this is the only Solana transaction required for instant redemption. After the signed transaction is broadcast, Nest’s cross-chain infrastructure processes the redeem and returns USDC through CCTP; the user does not submit a separate claim or finalize transaction.

dstEid is deprecated for the Solana redeem endpoint. The destination is Plume mainnet.

Sponsored instant redeem request body:

{
  "nestVaultSlug": "nest-treasury-vault",
  "rawAmountNestToken": 1000000,
  "owner": "<USER_SOLANA_PUBKEY>",
  "feePayer": "<RELAY_SOLANA_PUBKEY>"
}

Sponsored fee payer support

After receiving txBase64, decode the Solana VersionedTransaction. If feePayer was provided, assert that transaction.message.staticAccountKeys[0] equals the fee payer public key. The user signs as the owner or receiver, then the relay signs as fee payer and broadcasts.

For sponsored instant redeem and standard redemption (async) flows, the expected required signers are [feePayer, owner]. For sponsored mint, the receiver remains the USDC owner and Nest share receiver, while the sponsor pays fees. For first-time sponsored mint receivers, the receiver’s Nest share ATA must already exist; the sponsor can create it separately with an idempotent ATA transaction.

Browser SDK pattern

The direct Solana API uses rawAmountUsdc. This browser SDK version forwards an amountUsdc field to the API, so pass the raw 6-decimal base-unit amount when using this wrapper.

import { Connection } from "@solana/web3.js";
import { createNestBrowserClient } from "nest-sdk";

const connection = new Connection("https://api.mainnet-beta.solana.com", "confirmed");

const client = createNestBrowserClient({
  connection,
  wallet,
  config: {
    nestApiBaseUrl: "https://api.nest.credit",
  },
});

await client.mintNestToSolana({
  nestVaultSlug: "nest-treasury-vault",
  amountUsdc: 1000000,
  finality: "standard",
});

The SDK delegates transaction construction to the API, asks the user’s wallet to sign, and sends the signed transaction on Solana.

Errors and edge cases

Condition	Expected behavior
Unsupported vault slug	API returns 400.
Unsupported chain ID	EVM Actions API returns 400.
Unsupported asset for the selected chain	API returns 400.
Non-compliant wallet	EVM mint build returns 400; Solana mint build returns 403.
Deposit too small to mint shares	EVM quote/build returns 400.
Failed transaction simulation	EVM build-tx returns 400 unless skipSimulation is true.
RPC, indexer, or Predicate service issue	API returns 500.
Existing allowance is sufficient	approve may be omitted from returned transactions.

Implementation notes

• Treat every API amount as a raw integer amount.
• Use the API’s returned depositDecimals, shareDecimals, and redemptionDecimals when rendering UI values.
• Execute returned EVM transactions in order.
• Never assume approve is present. Render and execute the returned transactions[].
• Do not reuse quotes indefinitely. Re-quote close to the time the user signs.
• For direct contract integrations, prefer the registry and Smart Contracts page over copying addresses from old integration examples.