Ripio on/off-ramp for Privy wallets with 1:1 local stablecoins

'use client';

import { PrivyProvider } from '@privy-io/react-auth';
import { celo } from 'viem/chains';

export default function Providers({ children }: { children: React.ReactNode }) {
  return (
    <PrivyProvider
      appId={process.env.NEXT_PUBLIC_PRIVY_APP_ID!}
      config={{
        loginMethods: ['email', 'sms', 'google'],
        embeddedWallets: {
          ethereum: { createOnLogin: 'users-without-wallets' },
        },
        defaultChain: celo,
        supportedChains: [celo],
      }}
    >
      {children}
    </PrivyProvider>
  );
}

import { usePrivy, useWallets } from '@privy-io/react-auth';

export function useEmbeddedAddress() {
  const { ready, authenticated } = usePrivy();
  const { wallets } = useWallets();
  const embedded = wallets.find((w) => w.walletClientType === 'privy');
  return ready && authenticated ? embedded?.address : undefined;
}

// Server-side only
const RIPIO = process.env.RIPIO_BASE_URL ?? 'https://skala-sandbox.ripio.com';

let cachedToken: { value: string; expiresAt: number } | null = null;

async function getRipioToken() {
  if (cachedToken && Date.now() < cachedToken.expiresAt) return cachedToken.value;

  const basic = Buffer.from(`${process.env.RIPIO_CLIENT_ID}:${process.env.RIPIO_CLIENT_SECRET}`).toString('base64');
  const res = await fetch(`${RIPIO}/oauth2/token/`, {
    method: 'POST',
    headers: { Authorization: `Basic ${basic}`, 'Content-Type': 'application/x-www-form-urlencoded' },
    body: new URLSearchParams({ grant_type: 'client_credentials' }),
  });
  if (!res.ok) throw new Error(`Ripio auth failed: ${res.status}`);

  const { access_token, expires_in } = await res.json();
  cachedToken = { value: access_token, expiresAt: Date.now() + (expires_in - 60) * 1000 }; // refresh a minute early
  return access_token as string;
}

export async function ripio<T = any>(method: 'GET' | 'POST', path: string, body?: unknown): Promise<T> {
  const res = await fetch(`${RIPIO}${path}`, {
    method,
    headers: { Authorization: `Bearer ${await getRipioToken()}`, 'Content-Type': 'application/json' },
    body: body === undefined ? undefined : JSON.stringify(body),
  });
  if (!res.ok) throw await res.json().catch(() => ({ status: res.status })); // { code, type, detail, status }: branch on `code`
  return res.json();
}

// Server-side, run once at setup
import { ripio } from './ripio';

type Network = { network_name: string; assets?: { name: string; contract_address: string | null }[] };

export async function findWfiatNetworks(kind: 'withdrawal' | 'deposit', token: string) {
  const networks = await ripio<Network[]>('GET', `/api/v1/${kind}Networks/?include_currency=true`);
  return networks.flatMap((n) =>
    (n.assets ?? [])
      .filter((a) => a.contract_address?.toLowerCase() === token.toLowerCase())
      .map((a) => ({ chain: n.network_name, currency: a.name })),
  );
}

// In a one-off setup script. wFiat uses the same address on every EVM chain, so each call
// returns one entry per network: pick the one for your Privy wallet's chain (Celo here) and
// check it shows up in both lists, since on-ramp and off-ramp use the same RIPIO_CHAIN.
// await findWfiatNetworks('withdrawal', '0x0dc4f92879b7670e5f4e4e6e3c801d229129d90d');
// await findWfiatNetworks('deposit', '0x0dc4f92879b7670e5f4e4e6e3c801d229129d90d');

// Server-side, called by your app for the logged-in Privy user
import { ripio } from './ripio';

export async function createOnRamp(
  customerId: string,
  privyAddress: string,
  amountArs: string,
  externalRef: string, // a UUID you generate once per purchase and store with the order
) {
  const quote = await ripio('POST', '/api/v1/quotes/', {
    customerId,
    fromCurrency: 'ARS',
    toCurrency: process.env.RIPIO_WARS_CODE!,
    fromAmount: amountArs,
    chain: process.env.RIPIO_CHAIN!,
    paymentMethodType: 'bank_transfer',
  });

  const order = await ripio('POST', '/api/v1/onramp/', {
    customerId,
    quoteId: quote.quoteId,
    depositAddress: privyAddress, // the user's Privy embedded wallet
    externalRef,
    travelRule: { counterpartyIsSelf: true }, // Mexico: required from 2026-11-30; the user owns their Privy wallet
  });

  return { quote, transaction: order.transaction, paymentInstructions: order.fiatPaymentInstructions };
}

import { createHmac, timingSafeEqual } from 'crypto';

// Node lowercases header names: pass req.headers['http-x-wh-signature-256']
export function verifyRipioSignature(rawBody: Buffer, secret: string, header: string | undefined) {
  if (!header) return false;
  const expected = Buffer.from('sha256=' + createHmac('sha256', secret).update(rawBody).digest('hex'));
  const received = Buffer.from(header);
  return expected.length === received.length && timingSafeEqual(expected, received);
}

import { createPublicClient, http, erc20Abi, formatUnits } from 'viem';
import { celo } from 'viem/chains';

export const WARS = '0x0dc4f92879b7670e5f4e4e6e3c801d229129d90d'; // same address on every supported EVM chain

const client = createPublicClient({ chain: celo, transport: http() });

export async function getWarsBalance(owner: `0x${string}`) {
  const raw = await client.readContract({
    address: WARS,
    abi: erc20Abi,
    functionName: 'balanceOf',
    args: [owner],
  });
  return formatUnits(raw, 18);
}

// Server-side
import { ripio } from './ripio';

// 1. Create the account and return the resolved holder to your UI
export async function createPayoutAccount(customerId: string, cvuOrAlias: string) {
  const account = await ripio('POST', '/api/v1/fiatAccounts/', {
    customerId,
    paymentMethodType: 'bank_transfer',
    accountFields: { alias_or_cvu_destination: cvuOrAlias }, // Argentina; other countries use other fields
  });

  if (account.status === 'DISABLED') throw new Error('Payout account does not belong to the customer');

  // In Mexico and Colombia (breb) it starts as PROCESSING: poll List Fiat Accounts until it's UNCONFIRMED
  return { fiatAccountId: account.fiatAccountId as string, status: account.status, metadata: account.metadata };
}

// 2. Call it once the user has reviewed the holder in metadata and approved it
export async function confirmPayoutAccount(fiatAccountId: string) {
  await ripio('POST', `/api/v1/fiatAccounts/${fiatAccountId}/confirm/`);
  // The account then moves to ENABLED: wait for it before creating the session
}

// Server-side, once per user
import { ripio } from './ripio';

export async function createOffRampSession(fiatAccountId: string) {
  const session = await ripio('POST', '/api/v1/offrampSession/', {
    fiatAccountId,
    travelRule: { counterpartyIsSelf: true }, // Mexico: required from 2026-11-30; the user sends from their own wallet
  });
  const deposit = session.depositAddresses.find((d: { chain: string }) => d.chain === process.env.RIPIO_CHAIN);
  if (!deposit) throw new Error('No deposit address on the configured chain');
  return { sessionId: session.sessionId as string, depositAddress: deposit.address as `0x${string}` };
}

import { useSendTransaction } from '@privy-io/react-auth';
import { encodeFunctionData, erc20Abi, parseUnits } from 'viem';
import { WARS } from './balance';

export function useSendWars() {
  const { sendTransaction } = useSendTransaction();

  return (depositAddress: `0x${string}`, amountWars: string) =>
    sendTransaction({
      to: WARS,
      chainId: 42220, // Celo: must match the chain of the deposit address
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: 'transfer',
        args: [depositAddress, parseUnits(amountWars, 18)],
      }),
    });
}