Whop
Finance

import { getAavePoolAddress } from "@/lib/aave"

export async function POST(req: NextRequest) {
  const { asset, amount, onBehalfOf } = await req.json()
  const aavePool = getAavePoolAddress()

  // Entry function is on supply_logic, not pool
  const payload = {
    function: `${aavePool}::supply_logic::supply`,
    typeArguments: [],
    functionArguments: [asset, amount, onBehalfOf, 0],
  }

  return NextResponse.json({ payload })
}

// Leveraged yield: supply → borrow → re-supply loop
export function previewLoop(config: LoopConfig): LoopResult {
  const { initialAmount, targetLoops, ltv, safetyMargin,
          supplyApr, borrowApr } = config

  let totalSupplied = 0, totalBorrowed = 0
  let currentAmount = initialAmount

  for (let i = 0; i < targetLoops; i++) {
    totalSupplied += currentAmount
    const borrowed = currentAmount * ltv * safetyMargin
    totalBorrowed += borrowed
    currentAmount = borrowed
  }

  totalSupplied += currentAmount
  const effectiveLeverage = totalSupplied / initialAmount
  const netApy = supplyApr * effectiveLeverage
              - borrowApr * (effectiveLeverage - 1)
  const healthFactor = totalBorrowed > 0
    ? (totalSupplied * LIQUIDATION_THRESHOLD) / totalBorrowed
    : Infinity

  return { totalSupplied, totalBorrowed, effectiveLeverage,
           netApy, healthFactor }
}

// Market order: IOC time-in-force, price=0
const sizeRaw = Math.round(
  Number(size) * Math.pow(10, marketConfig.sizeDecimals)
)

const payload = {
  function: `${pkg}::dex_accounts_entry::place_order_to_subaccount`,
  typeArguments: [],
  functionArguments: [
    subaccount,           // subaccount address
    marketConfig.address, // market address (BTC-USDT, AAPL, etc.)
    "0",                  // price (0 = market price for IOC)
    String(sizeRaw),      // size in contract units
    isBuy,                // true = long, false = short
    2,                    // time_in_force: IOC (market order)
    false,                // post_only
    reduceOnly,           // reduce_only
  ],
}

// Frontend: build payload via API, sign with wallet adapter
const res = await fetch("/api/decibel/order", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    marketName, price: currentPrice,
    size: parseFloat(size),
    isBuy: side === "buy", orderType, subaccount,
  }),
})

const data = await res.json()
const result = await signAndSubmitTransaction({
  data: data.payload,
})

// USDT Fungible Asset address on Aptos mainnet
const USDT_FA = "0x357b0b74bc833e95a115ad22604854d6b0fca151..."

// Build payload for client-side signing via wallet adapter
const payload = {
  function: "0x1::primary_fungible_store::transfer" as const,
  typeArguments: ["0x1::fungible_asset::Metadata"],
  functionArguments: [USDT_FA, recipient, amount],
}

return NextResponse.json({ payload })

// Server-side demo: send real USDT between two accounts
const rawAmount = Math.floor(amount * 1e6)  // USDT = 6 decimals

const sender = Account.fromPrivateKey({
  privateKey: new Ed25519PrivateKey(keyA),
})

// Build the FA transfer transaction
const txn = await aptos.transferFungibleAsset({
  sender,
  fungibleAssetMetadataAddress: AccountAddress.from(USDT_FA),
  recipient: receiverAddr,
  amount: rawAmount,
})

// Sign, submit, and wait for confirmation
const pending = await aptos.signAndSubmitTransaction({
  signer: sender, transaction: txn,
})
const result = await aptos.waitForTransaction({
  transactionHash: pending.hash,
})

# Install the Aptos CLI
$ brew install aptos

# Initialize a new Move project
$ aptos move init --name my_defi_module

# Compile Move modules
$ aptos move compile

# Run Move unit tests
$ aptos move test

# Deploy to mainnet
$ aptos move publish --profile mainnet

module whop::vault {
    use aptos_framework::fungible_asset;
    use aptos_framework::primary_fungible_store;

    /// A vault that holds fungible assets
    struct Vault has key, store {
        balance: FungibleStore,
        owner: address,
    }

    /// Deposit USDT into the vault
    public entry fun deposit(
        account: &signer,
        amount: u64
    ) {
        // Resources can't be copied — only moved
        let fa = primary_fungible_store::withdraw(
            account, USDT_METADATA, amount
        );
        fungible_asset::deposit(vault_store, fa);
    }
}