Fiat On-Ramp and Off-Ramp Integration with Ankara Chain

import { ManualRampProvider, RampManager } from "@ankarachain/sdk";

const provider = new ManualRampProvider({
  // Rates: tokens per 1 unit of fiat
  // Default: { NGN: 1/1500, KES: 1/150, GHS: 1/15 }
  exchangeRates: { NGN: 1 / 1500, KES: 1 / 150, GHS: 1 / 15 },
  feeBps:        100,  // 1% flat fee
});

const ramp = new RampManager(provider);

import { RampManager } from "@ankarachain/sdk";

// Use the static factory method — it constructs the StellarAnchorProvider for you
const ramp = RampManager.connectAnchor(
  "cowrie.exchange",     // home domain of the anchor
  freighterSigner,       // StellarExternalSigner (e.g. Freighter)
  adapter,               // optional — provide if you also want on-chain settlement
  { settlementAddress: "CSettlementContractId" }
);

import { createRampProvider } from "@ankarachain/sdk/server";
import { RampManager } from "@ankarachain/sdk";
import type { RampProviderSelection } from "@ankarachain/sdk";

const selection: RampProviderSelection = {
  provider:  "moonpay",
  apiKey:    process.env.MOONPAY_API_KEY!,
  secretKey: process.env.MOONPAY_SECRET_KEY!,
  sandbox:   true,   // remove for production
};

const provider = createRampProvider(selection);
const ramp     = new RampManager(provider);

import type {
  RampProvider,
  RampQuoteInput, RampQuote,
  InitiateOnRampInput, InitiateOffRampInput,
  RampSession, RampSessionStatus,
} from "@ankarachain/sdk";

class YellowCardProvider implements RampProvider {
  readonly name = "yellow-card";

  async getQuote(input: RampQuoteInput): Promise<RampQuote> {
    // call Yellow Card's pricing API ...
  }

  async initiateOnRamp(input: InitiateOnRampInput): Promise<RampSession> {
    // start a Yellow Card deposit session ...
  }

  async initiateOffRamp(input: InitiateOffRampInput): Promise<RampSession> {
    // start a Yellow Card withdrawal session ...
  }

  async getStatus(sessionId: string): Promise<RampSessionStatus> {
    // poll Yellow Card for status ...
  }
}

import { createRampProvider } from "@ankarachain/sdk/server";

// ManualRampProvider — dev/testing, no credentials required
const provider = createRampProvider({
  provider: "manual",
  exchangeRates: { NGN: 1 / 1500 },
  feeBps: 150,
});

import { createRampProvider } from "@ankarachain/sdk/server";
import { RampManager, ManualRampProvider } from "@ankarachain/sdk";

const ramp = RampManager.withProviders({
  onRamp:  createRampProvider({ provider: "moonpay", apiKey: "...", secretKey: "..." }),
  offRamp: new ManualRampProvider(),
});

import type { RampQuoteInput, RampQuote } from "@ankarachain/sdk";

const input: RampQuoteInput = {
  direction:    "on-ramp",
  fiatCurrency: "NGN",
  tokenSymbol:  "mUSD",
  countryCode:  "NG",
  fiatAmount:   "150000",   // user wants to spend 150 000 NGN
};

const quote: RampQuote = await ramp.getQuote(input);

console.log(`${quote.fiatAmount} ${quote.fiatCurrency}`);
  // "150000.00 NGN"
console.log(`→ ${quote.tokenAmount} ${quote.tokenSymbol}`);
  // "→ 100.000000 mUSD"
console.log(`Rate: ${quote.exchangeRate}`);
  // "Rate: 0.0006666666..."
console.log(`Fee:  ${quote.feeFiat} ${quote.fiatCurrency}`);
  // "Fee:  1500.00 NGN"
console.log(`Expires: ${new Date(quote.expiresAt * 1000).toISOString()}`);

interface RampQuote {
  direction:    "on-ramp" | "off-ramp";
  fiatCurrency: string;   // e.g. "NGN"
  fiatAmount:   string;
  tokenAmount:  string;
  tokenSymbol:  string;
  exchangeRate: string;
  feeFiat:      string;   // flat fee in fiat units
  expiresAt:    number;   // Unix seconds
}

import type { InitiateOnRampInput, RampSession } from "@ankarachain/sdk";

const input: InitiateOnRampInput = {
  fiatAmount:        "150000",
  fiatCurrency:      "NGN",
  tokenSymbol:       "mUSD",
  recipientAddress:  "0xInvestorAddress",
  countryCode:       "NG",
  customerReference: "ORDER-2025-001",   // optional — your internal reference
};

const session: RampSession = await ramp.initiateOnRamp(input);

console.log("Session ID: ", session.sessionId);
console.log("Payment URL:", session.paymentUrl);  // redirect the user here
console.log("Status:     ", session.status);       // RampSessionStatus.PENDING

import { RampSessionStatus } from "@ankarachain/sdk";

const status = await ramp.getStatus(session.sessionId);

if (status === RampSessionStatus.SETTLED) {
  // payment confirmed — mint tokens to the recipient
  await registry.mint("0xInvestorAddress", ethers.parseEther("100"));
}

import type { InitiateOffRampInput, RampPayoutAccount } from "@ankarachain/sdk";

// Bank account
const payoutAccount: RampPayoutAccount = {
  type:          "bank",
  accountNumber: "0123456789",
  accountName:   "Amara Okafor",
  bankCode:      "058",   // Guaranty Trust Bank Nigeria
};

// — or — mobile money
const payoutAccount: RampPayoutAccount = {
  type:          "mobile-money",
  accountNumber: "+254712345678",
  accountName:   "Wanjiru Kamau",
  provider:      "M-Pesa",
};

const input: InitiateOffRampInput = {
  tokenAmount:  "100",
  tokenSymbol:  "mUSD",
  fiatCurrency: "NGN",
  payoutAccount,
  countryCode:  "NG",
};

const session = await ramp.initiateOffRamp(input);
console.log("Off-ramp session:", session.sessionId);

import type { DeployRampSettlementOptions } from "@ankarachain/sdk";

const opts: DeployRampSettlementOptions = {
  treasury: "0xTreasuryAddress",  // receives confirmed off-ramp tokens
};

const settlementResult = await factory.deployRampSettlement(opts);
console.log("Settlement contract:", settlementResult.settlementAddress);

const ramp = new RampManager(provider, factory.adapter, {
  settlementAddress: settlementResult.settlementAddress,
});

// EVM: approve the settlement contract to spend the off-ramp amount
const token = new ethers.Contract(mUSDAddress, erc20Abi, signer);
await token.approve(ramp.settlementAddress, ethers.parseEther("100"));

// Deposit — tokens move from the user's wallet to the settlement contract
const txHash = await ramp.depositOffRamp(
  session.sessionId,
  mUSDAddress,
  ethers.parseEther("100")
);

const txHash = await ramp.confirmOffRampSettlement(session.sessionId);
console.log("Settlement confirmed:", txHash);

await ramp.recordOnRampSettlement(
  session.sessionId,
  "0xInvestorAddress",
  mUSDAddress,
  ethers.parseEther("100")
);

# Get a quote
ankara ramp-quote \
  --direction on-ramp \
  --fiat-currency NGN \
  --token-symbol mUSD \
  --fiat-amount 150000

# Initiate an on-ramp session
ankara onramp-initiate \
  --fiat-amount 150000 \
  --fiat-currency NGN \
  --token-symbol mUSD \
  --recipient 0xInvestorAddress

# Initiate an off-ramp session
ankara offramp-initiate \
  --token-amount 100 \
  --token-symbol mUSD \
  --fiat-currency NGN \
  --payout-type bank \
  --account-number 0123456789 \
  --bank-code 058

# Poll session status
ankara ramp-status --session-id <sessionId>

# Confirm an off-ramp settlement (platform admin)
ankara offramp-confirm --session-id <sessionId>

enum RampSessionStatus {
  PENDING    = "pending",     // session created, awaiting user action
  PROCESSING = "processing",  // fiat payment received, clearing in progress
  SETTLED    = "settled",     // fiat confirmed — safe to mint / release tokens
  FAILED     = "failed",      // payment failed or expired
  REFUNDED   = "refunded",    // tokens returned to depositor (off-ramp)
}