SDK & Integration

# Core dependencies
npm install viem @tanstack/react-query

# iExec Nox handle client (ERC-7984 encryption)
npm install @iexec-nox/handle

import { createWalletClient, custom } from 'viem'
import { arbitrumSepolia } from 'viem/chains'
import { createViemHandleClient } from '@iexec-nox/handle'

// Build inside an async function (after wallet is connected)
const eth = window.ethereum  // MetaMask EIP-1193 provider
const viemWallet = createWalletClient({
  chain: arbitrumSepolia,
  transport: custom(eth),
})

// createViemHandleClient is async — must await
const handleClient = await createViemHandleClient(viemWallet)

// encryptInput takes 3 positional args — NOT an object
const { handle, handleProof } = await handleClient.encryptInput(
  100n,                              // value: number | bigint
  'uint256',                         // Solidity type string
  '0x853D51fB...' as `0x${string}`  // PropertyToken contract address
)

// handle      → bytes32  (opaque encrypted pointer to "100")
// handleProof → bytes    (Intel TDX TEE attestation)
// Both are single-use — re-encrypt before each purchaseTokens call

import { createWalletClient, custom, encodeFunctionData } from 'viem'
import { arbitrumSepolia } from 'viem/chains'
import { createViemHandleClient } from '@iexec-nox/handle'
import { ADDRESSES, ERC20_ABI, PROPERTY_TOKEN_ABI } from '@/app/lib/contracts'

const eth = window.ethereum

// Manual receipt polling — avoids MetaMask RPC rate-limits
async function waitForReceipt(hash: string) {
  for (let i = 0; i < 40; i++) {
    await new Promise(r => setTimeout(r, 3000))
    const r = await eth.request({ method: 'eth_getTransactionReceipt', params: [hash] })
    if (r) return r  // r.status === '0x1' success, '0x0' reverted
  }
  throw new Error('Not confirmed after 2 min')
}

// Step 1 — Encrypt via Nox TEE (gasless EIP-712 sign)
const viemWallet = createWalletClient({ chain: arbitrumSepolia, transport: custom(eth) })
const handleClient = await createViemHandleClient(viemWallet)
const { handle, handleProof } = await handleClient.encryptInput(
  tokenAmount, 'uint256', propertyTokenAddress as `0x${string}`
)

// Step 2 — Approve payment token (USDT / USDC / CEST)
// USDT + USDC: 6 decimals ($1.00 = 1_000_000). CEST: 18 decimals ($0.04/CEST).
// Example: USDT path (default)
const payToken = ADDRESSES.usdt           // or ADDRESSES.usdc, or ADDRESSES.cestToken
const payAmount = BigInt(tokenAmount) * 1_000_000n  // USDT/USDC: 6 dec
// CEST path: BigInt(Math.round(tokenAmount / 0.04)) * 10n**18n
const approveData = encodeFunctionData({
  abi: ERC20_ABI, functionName: 'approve',
  args: [propertyTokenAddress, payAmount],
})
const approveTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: payToken, data: approveData, gas: '0x13880' }] })
const approveRx = await waitForReceipt(approveTx as string)
if (approveRx.status === '0x0') throw new Error('Approval reverted')

// Step 3 — purchaseTokens (encrypted balance stored on-chain)
const buyData = encodeFunctionData({
  abi: PROPERTY_TOKEN_ABI, functionName: 'purchaseTokens',
  args: [handle as `0x${string}`, handleProof as `0x${string}`, BigInt(tokenAmount)],
})
const purchaseTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: propertyTokenAddress, data: buyData, gas: '0x493E0' }] })
const purchaseRx = await waitForReceipt(purchaseTx as string)
if (purchaseRx.status === '0x0') throw new Error('Purchase reverted')

import { encodeFunctionData } from 'viem'
import { ADDRESSES, PROPERTY_TOKEN_ABI, SECONDARY_MARKET_ABI } from '@/app/lib/contracts'

// Step 1 — Grant SecondaryMarket as operator (7-day expiry)
const expiry = BigInt(Math.floor(Date.now() / 1000) + 7 * 24 * 3600)
const grantData = encodeFunctionData({
  abi: PROPERTY_TOKEN_ABI, functionName: 'grantOperator',
  args: [ADDRESSES.secondaryMarket, expiry],
})
const grantTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: propertyTokenAddress, data: grantData, gas: '0x30D40' }] })
const grantRx = await waitForReceipt(grantTx as string)
if (grantRx.status === '0x0') throw new Error('grantOperator reverted')

// Step 2 — Create listing (pricePerToken in USDT 6 decimals: $1.025 = 1_025_000)
const pricePerTokenUsdt = BigInt(Math.round(parseFloat(sellPrice) * 1_000_000))
const listData = encodeFunctionData({
  abi: SECONDARY_MARKET_ABI, functionName: 'createListing',
  args: [
    propertyTokenAddress as `0x${string}`,  // address tokenContract
    BigInt(propertyId),                        // uint256 propertyId
    BigInt(tokenAmount),                       // uint256 tokenAmount
    pricePerTokenUsdt,                         // uint256 pricePerToken
  ],
})
const listTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: ADDRESSES.secondaryMarket, data: listData, gas: '0x493E0' }] })
const listRx = await waitForReceipt(listTx as string)
if (listRx.status === '0x0') throw new Error('createListing reverted')
// listingId is emitted in the tx logs — query via getLogs or Arbiscan

import { encodeFunctionData } from 'viem'
import { ADDRESSES, ERC20_ABI, SECONDARY_MARKET_ABI } from '@/app/lib/contracts'

// totalCost = tokenAmount × pricePerToken (USDT 6 dec, BigInt)
const totalUsdt = listing.tokenAmount * listing.pricePerToken

// Step 1 — Approve USDT to SecondaryMarket
const approveData = encodeFunctionData({
  abi: ERC20_ABI, functionName: 'approve',
  args: [ADDRESSES.secondaryMarket, totalUsdt],
})
const approveTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: ADDRESSES.usdt, data: approveData, gas: '0x13880' }] })
const approveRx = await waitForReceipt(approveTx as string)
if (approveRx.status === '0x0') throw new Error('USDT approval reverted')

// Step 2 — Execute buy (0.5% fee deducted)
const buyData = encodeFunctionData({
  abi: SECONDARY_MARKET_ABI, functionName: 'executeBuy',
  args: [BigInt(listingId)],
})
const buyTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: ADDRESSES.secondaryMarket, data: buyData, gas: '0x61A80' }] })
const buyRx = await waitForReceipt(buyTx as string)
if (buyRx.status === '0x0') throw new Error('executeBuy reverted')

import { encodeFunctionData } from 'viem'
import { PROPERTY_TOKEN_ABI } from '@/app/lib/contracts'
import { PROPERTIES } from '@/app/lib/propertiesData'

const eth = window.ethereum
const address = '0xYOUR_WALLET'

// Resolve property contract address
const property = PROPERTIES.find(p => p.id === 'pearl-dxb-001')
const propertyTokenAddress = property.contractAddress

// Step 1 — Grant recipient as operator (7-day window)
const expiry = BigInt(Math.floor(Date.now() / 1000) + 7 * 24 * 3600)
const grantData = encodeFunctionData({
  abi: PROPERTY_TOKEN_ABI, functionName: 'grantOperator',
  args: [recipientAddress as `0x${string}`, expiry],
})
const grantTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: propertyTokenAddress, data: grantData, gasPrice }] })

// The recipient wallet can now call confidentialTransferFrom for up to 7 days.
// Transfer amounts are encrypted — no observer knows how much moved.
// Revoke early by re-calling grantOperator with expiry = 0.

import { encodeFunctionData } from 'viem'
import { ADDRESSES, GOVERNANCE_ABI } from '@/app/lib/contracts'

const eth = window.ethereum
const address = '0xYOUR_WALLET'

// proposalId from ConfidentialGovernance (uint256)
// option: 0 = For, 1 = Against, 2 = Abstain
const voteData = encodeFunctionData({
  abi: GOVERNANCE_ABI, functionName: 'castVote',
  args: [BigInt(proposalId), 0],  // 0 = Vote For
})

const voteTx = await eth.request({ method: 'eth_sendTransaction',
  params: [{ from: address, to: ADDRESSES.confidentialGovernance, data: voteData, gasPrice }] })
const voteRx = await waitForReceipt(voteTx as string)
if (voteRx.status === '0x0') throw new Error('castVote reverted — not a holder or proposal closed')

// IMPORTANT:
// - Voting is by PropertyToken holder status (1 holder = 1 vote)
// - CEST tokens do NOT determine voting power in ConfidentialGovernance
// - CEST ERC20Votes is reserved for future DAO delegation (Phase 2)
// - Proposals are created via createProposal(propertyId, proposalType, description)

import { createPublicClient, custom } from 'viem'
import { arbitrumSepolia } from 'viem/chains'
import { ADDRESSES, SECONDARY_MARKET_ABI } from '@/app/lib/contracts'

const publicClient = createPublicClient({
  chain: arbitrumSepolia,
  transport: custom(window.ethereum),
})

const listing = await publicClient.readContract({
  address: ADDRESSES.secondaryMarket,
  abi: SECONDARY_MARKET_ABI,
  functionName: 'listings',
  args: [BigInt(listingId)],
})

// listing → {
//   listingId:    bigint,
//   seller:       `0x${string}`,
//   tokenContract:`0x${string}`,
//   propertyId:   bigint,
//   tokenAmount:  bigint,
//   pricePerToken:bigint,   // USDT 6 decimals
//   listedAt:     bigint,   // unix timestamp
//   active:       boolean,
// }