Private Credit Yield via ZIG Markets Vaults

npm install @getpara/react-sdk-lite @getpara/wagmi-v2-integration @wagmi/core viem @tanstack/react-query

import ParaWeb, { Environment } from "@getpara/react-sdk-lite";
import "@getpara/react-sdk-lite/styles.css";
import { paraConnector } from "@getpara/wagmi-v2-integration";
import { createConfig, http, connect, getAccount } from "@wagmi/core";
import { mainnet } from "@wagmi/core/chains";
import { QueryClient } from "@tanstack/react-query";

const para = new ParaWeb(Environment.PROD, PARA_API_KEY);

export const config = createConfig({
  chains: [mainnet],
  transports: { [mainnet.id]: http(RPC_URL) },
  connectors: [paraConnector({ para, appName: "Para × ZIG Markets", options: {},
                               queryClient: new QueryClient() }) as any],
});

// Opens Para's auth modal if the user is not logged in
await connect(config, { connector: config.connectors[0] });
const { address } = getAccount(config);

// on USDT (non-standard ERC-20: approve returns no bool, and a non-zero
// allowance must be reset to 0 before being changed)
function approve(address spender, uint256 value)

// on the vault
function deposit(uint256 amount) returns (uint256 shares)
function depositWithMinShares(uint256 amount, uint256 minSharesOut, uint256 deadline) returns (uint256 shares)
function requestRedeem(uint256 shares) returns (uint256 id)
function requestRedeemWithMinAssets(uint256 shares, uint256 minAssetsOut, uint256 deadline) returns (uint256 id)
function cancelRequest(uint256 id)               // user, only after cancelAfter
function claim() returns (uint256)               // edge case only: payouts are normally pushed
function balanceOf(address) returns (uint256)    // ERC-20, 6 decimals
function pricePerShare() view returns (uint256)  // NAV per share, 1e18 fixed-point
function previewDeposit(uint256 amount) view returns (uint256 shares)
function previewRedeem(uint256 shares) view returns (uint256 assets)
function latestAum() view returns (uint256)      // TVL in USDT units (6 dec)
function getRequest(uint256 id) view returns (RedemptionRequest)
// RedemptionRequest: user, shares, assetAmount, outstanding, originalPps, overridePps,
// requestedAt, cancelAfter, status (1 Pending, 2 Approved, 3 Funded, 4 Rejected, 5 Cancelled, 6 Settled)

Deposited(address indexed user, uint256 assets, uint256 shares, uint256 forwardedToStrategy)
RedemptionRequested(uint256 indexed id, address indexed user, uint256 shares, uint256 assetAmount)
RedemptionApproved(uint256 indexed id, address indexed user, uint256 assetAmount, uint256 originalPps, uint256 overridePps)
RedemptionRejected(uint256 indexed id, address indexed user, uint256 shares)
RedemptionCancelled(uint256 indexed id, address indexed user, uint256 shares)
RedemptionFunded(uint256 indexed id, address indexed user, uint256 amount, bool fullyFunded)
RedemptionSettled(uint256 indexed id, address indexed user, uint256 amount)
Claimed(address indexed user, uint256 amount)
AumUpdated(uint256 oldAum, uint256 newAum, uint256 newPricePerShare)

import { readContract, writeContract, waitForTransactionReceipt, getAccount } from "@wagmi/core";
import { parseAbi, parseUnits, formatUnits } from "viem";
import { config } from "./para";   // Step 2

const VAULT = "0x6FE78B942C566fE2b8D0881cf3577C1B1511F204";
const USDT  = "0xdAC17F958D2ee523a2206206994597C13D831ec7";

const VAULT_ABI = parseAbi([
  "function deposit(uint256 amount) returns (uint256)",
  "function requestRedeem(uint256 shares) returns (uint256)",
  "function balanceOf(address) view returns (uint256)",
  "function pricePerShare() view returns (uint256)",
  "function latestAum() view returns (uint256)",
]);
// USDT quirk: approve returns no bool; non-zero allowance must reset to 0 first
const USDT_ABI = parseAbi([
  "function approve(address spender, uint256 value)",
  "function allowance(address owner, address spender) view returns (uint256)",
]);

const { address } = getAccount(config);

// 1) approve, with USDT's reset-to-zero rule
const amount = parseUnits("10", 6); // 10 USDT minimum deposit
const allowance = await readContract(config, { address: USDT, abi: USDT_ABI,
  functionName: "allowance", args: [address!, VAULT] });
if (allowance < amount) {
  if (allowance > 0n) {
    const h = await writeContract(config, { address: USDT, abi: USDT_ABI,
      functionName: "approve", args: [VAULT, 0n] });
    await waitForTransactionReceipt(config, { hash: h });
  }
  const h = await writeContract(config, { address: USDT, abi: USDT_ABI,
    functionName: "approve", args: [VAULT, amount] });
  await waitForTransactionReceipt(config, { hash: h });
}

// 2) deposit: mints nzUSDT to the Para wallet in the same tx
const h = await writeContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "deposit", args: [amount] });
await waitForTransactionReceipt(config, { hash: h });

// 3) read the position
const [shares, pps] = await Promise.all([
  readContract(config, { address: VAULT, abi: VAULT_ABI, functionName: "balanceOf", args: [address!] }),
  readContract(config, { address: VAULT, abi: VAULT_ABI, functionName: "pricePerShare" }),
]);
console.log(`${formatUnits(shares, 6)} nzUSDT ≈ ${formatUnits(shares * pps / 10n ** 18n, 6)} USDT`);

// 4) exit: burns shares now; payout is pushed to the wallet under the vault's settlement terms
const r = await writeContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "requestRedeem", args: [shares] });
await waitForTransactionReceipt(config, { hash: r });
// Track status with getRequest(id) or the RedemptionApproved / RedemptionSettled events.

// on the asset (USDC / USDT)
function approve(address spender, uint256 amount)

// subscribe: synchronous, shares mint to msg.sender
function deposit(uint256 amount) returns (uint256 shares)

// exit: asynchronous, two-step
function requestRedeem(uint256 shares) returns (uint64 requestId, uint256 assetAmount)
function cancelRedeem(uint64 requestId)                        // user may cancel before approval

// position and pricing
function balanceOf(address) view returns (uint256)
function assetForShares(uint256 shares) view returns (uint256)
function sharesForAsset(uint256 assets) view returns (uint256)
function redemptionQuote(uint256 shares) view returns (uint256)
function pricePerFullShare() view returns (uint256 price, uint256 supply, uint256 aum)   // price scaled by 1e18
function aum() view returns (uint256)
function effectiveAum() view returns (uint256)
function lastAumUpdateAt() view returns (uint64)
function userRequests(address user, uint256 offset, uint256 limit) view returns (RedemptionRequest[])
function request(uint64 id) view returns (RedemptionRequest)
// RedemptionRequest: id, user, shares, assetAmount, originalNav, timestamp, status,
// approvedAt, approvedBy, overrideNav, hasOverride

// metadata
function asset() · name() · symbol() · decimals() · totalSupply() · maxSupply() · paused()

Deposit(address indexed user, uint256 assetAmount, uint256 sharesMinted, uint256 totalSupply, uint256 nav, uint256 aum)
RedemptionRequested(uint64 indexed requestId, address indexed user, uint256 shares, uint256 assetAmount, uint256 nav, uint256 aum)
RedemptionApproved(uint64 indexed requestId, address indexed user, address indexed settledBy, uint256 shares, uint256 assetAmount, uint256 settleNav, uint256 originalNav, bool hasOverride)
RedemptionRejected(uint64 indexed requestId, address indexed user, address indexed rejectedBy, uint256 sharesRefunded)
RedemptionCancelled(uint64 indexed requestId, address indexed user, uint256 sharesRefunded)
RedemptionSettledInstantly(address indexed user, uint256 shares, uint256 assetAmount, uint256 nav, uint256 aum)
AumUpdated(uint256 previousAum, uint256 aum, uint256 changeBps, uint256 nav, uint256 totalSupply)
RewardAdded(address indexed addedBy, uint256 rewardAmount, uint256 previousAum, uint256 aum)

import { readContract, writeContract, waitForTransactionReceipt, getAccount } from "@wagmi/core";
import { parseAbi, parseUnits, formatUnits } from "viem";
import { config } from "./para";   // Step 2

const VAULT = "0x...";   // the Valdora vault deployed for your integration
const USDC  = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";

const VAULT_ABI = parseAbi([
  "function deposit(uint256 amount) returns (uint256)",
  "function requestRedeem(uint256 shares) returns (uint64, uint256)",
  "function balanceOf(address) view returns (uint256)",
  "function assetForShares(uint256 shares) view returns (uint256)",
  "function pricePerFullShare() view returns (uint256, uint256, uint256)",
  "function lastAumUpdateAt() view returns (uint64)",
]);
const ERC20_ABI = parseAbi([
  "function approve(address spender, uint256 amount) returns (bool)",
]);

const { address } = getAccount(config);

// 0) guard: a vault with no NAV yet returns 0 on every price read
const updatedAt = await readContract(config, { address: VAULT, abi: VAULT_ABI, functionName: "lastAumUpdateAt" });
if (updatedAt === 0n) throw new Error("Vault has no NAV yet");

// 1) approve (USDC returns a bool; for USDT use the allowance reset pattern from Path A)
const amount = parseUnits("100", 6);
const a = await writeContract(config, { address: USDC, abi: ERC20_ABI,
  functionName: "approve", args: [VAULT, amount] });
await waitForTransactionReceipt(config, { hash: a });

// 2) deposit: shares mint to the Para wallet in the same tx
const d = await writeContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "deposit", args: [amount] });
await waitForTransactionReceipt(config, { hash: d });

// 3) read the position
const shares = await readContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "balanceOf", args: [address!] });
const value  = await readContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "assetForShares", args: [shares] });
console.log(`${formatUnits(shares, 6)} shares ≈ ${formatUnits(value, 6)} USDC`);

// 4) exit: files the request only; an operator approves it and settlement follows the vault's terms
const r = await writeContract(config, { address: VAULT, abi: VAULT_ABI,
  functionName: "requestRedeem", args: [shares] });
await waitForTransactionReceipt(config, { hash: r });
// Track status with userRequests(address, 0, 10) or the RedemptionApproved event.