npm install @solana/wallet-adapter-react \
           @solana/wallet-adapter-react-ui \
           @solana/wallet-adapter-wallets \
           @solana/wallet-adapter-base \
           @solana/web3.js

// components/WalletProvider.tsx
"use client";

import { FC, ReactNode, useMemo } from "react";
import {
  ConnectionProvider,
  WalletProvider,
} from "@solana/wallet-adapter-react";
import { WalletModalProvider } from "@solana/wallet-adapter-react-ui";
import { PhantomWalletAdapter } from "@solana/wallet-adapter-wallets";
import "@solana/wallet-adapter-react-ui/styles.css";

const DEVNET_RPC = "https://api.devnet.solana.com";

export const AppWalletProvider: FC<{ children: ReactNode }> = ({ children }) => {
  const wallets = useMemo(() => [new PhantomWalletAdapter()], []);

  return (
    <ConnectionProvider endpoint={DEVNET_RPC}>
      <WalletProvider wallets={wallets} autoConnect>
        <WalletModalProvider>{children}</WalletModalProvider>
      </WalletProvider>
    </ConnectionProvider>
  );
};

"use client"; // this hook can only be used in client components

import { useMemo } from "react";
import { AnchorProvider, Program } from "@coral-xyz/anchor";
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import { PublicKey } from "@solana/web3.js";
import idl from "./mora_idl.json"; // download from GitHub repo

const MORA_PROGRAM_ID = new PublicKey(
  "9fcXHD3pHDKLX79JuVgCEKQiqYkvVqFtpoAEVjBq4aJ8"
);

function useMoraProgram() {
  const { connection } = useConnection();
  const wallet = useWallet();

  return useMemo(() => {
    const provider = new AnchorProvider(
      connection,
      wallet as any, // wallet-adapter satisfies AnchorWallet interface
      { commitment: "confirmed" }
    );
    return new Program(idl, MORA_PROGRAM_ID, provider);
  }, [connection, wallet]);
}

npm install @coral-xyz/anchor @solana/web3.js tweetnacl
# Download IDL:
# https://github.com/nzengi/mora/blob/main/target/idl/mora.json

import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";

interface MoraVoucher {
  escrow: PublicKey;
  nonce: bigint;         // u64 — increment per payment
  payee: PublicKey;
  amount: bigint;        // lamports (u64)
  signature: Uint8Array; // 64-byte Ed25519 sig
}

interface EscrowAccount {
  payer: PublicKey;
  amount: BN;
  seed: BN;
  expiresAt: BN;
}

import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";
import { Buffer } from "buffer";

const MORA_PROGRAM_ID = new PublicKey(
  "9fcXHD3pHDKLX79JuVgCEKQiqYkvVqFtpoAEVjBq4aJ8"
);

function deriveEscrowPda(payer: PublicKey, seed: number): PublicKey {
  const seedBuffer = Buffer.alloc(8);
  seedBuffer.writeBigUInt64LE(BigInt(seed)); // Date.now() fits in u64 safely

  const [escrowPda] = PublicKey.findProgramAddressSync(
    [payer.toBuffer(), seedBuffer],
    MORA_PROGRAM_ID
  );
  return escrowPda;
}

// Usage — wallet.publicKey comes from useWallet() (see Wallet Setup section)
const escrowPda = deriveEscrowPda(wallet.publicKey, Date.now());

import { Buffer } from "buffer"; // npm install buffer (browser polyfill)

// Both nonce and amount are 8-byte little-endian unsigned 64-bit integers

// nonce — increment per voucher to prevent replay
const nonce = BigInt(1); // start at 1, increment each payment
const nonceBuffer = Buffer.alloc(8);
nonceBuffer.writeBigUInt64LE(nonce);

// amount — payment in lamports (1 SOL = 1_000_000_000 lamports)
const lamports = BigInt(500_000_000); // 0.5 SOL
const amountBuffer = Buffer.alloc(8);
amountBuffer.writeBigUInt64LE(lamports);

import { AnchorProvider, Program, BN } from "@coral-xyz/anchor";
import { PublicKey, Keypair } from "@solana/web3.js";
import { Buffer } from "buffer"; // npm install buffer
import nacl from "tweetnacl";
import idl from "./mora_idl.json";
// MoraVoucher and EscrowAccount interfaces: see TypeScript Types section above

const MORA_PROGRAM_ID = new PublicKey(
  "9fcXHD3pHDKLX79JuVgCEKQiqYkvVqFtpoAEVjBq4aJ8"
);

async function createEscrow(
  program: Program,
  wallet: { publicKey: PublicKey },
  totalLamports: bigint
): Promise<PublicKey> {
  const seed = Date.now(); // number — fits in u64 safely
  const seedBuffer = Buffer.alloc(8);
  seedBuffer.writeBigUInt64LE(BigInt(seed));

  const [escrowPda] = PublicKey.findProgramAddressSync(
    [wallet.publicKey.toBuffer(), seedBuffer],
    MORA_PROGRAM_ID
  );

  await program.methods
    .createEscrow(new BN(totalLamports.toString()))
    .accounts({ payer: wallet.publicKey, escrow: escrowPda })
    .rpc();

  return escrowPda;
}

function signVoucher(
  escrow: PublicKey,
  nonce: bigint,
  payee: PublicKey,
  amount: bigint,
  keypair: Keypair
): MoraVoucher {
  const nonceBuffer = Buffer.alloc(8);
  nonceBuffer.writeBigUInt64LE(nonce);

  const amountBuffer = Buffer.alloc(8);
  amountBuffer.writeBigUInt64LE(amount);

  const msg = Buffer.concat([
    Buffer.from("MORA"),
    escrow.toBuffer(),
    nonceBuffer,
    payee.toBuffer(),
    amountBuffer,
  ]);

  const signature = nacl.sign.detached(msg, keypair.secretKey);
  return { escrow, nonce, payee, amount, signature };
}

async function settleVoucher(
  program: Program,
  voucher: MoraVoucher,
  settler: { publicKey: PublicKey }
): Promise<string> {
  try {
    const txSig = await program.methods
      .settle(Buffer.from(voucher.signature))
      .accounts({ settler: settler.publicKey, escrow: voucher.escrow })
      .rpc({ commitment: "confirmed" });
    return txSig;
  } catch (err: unknown) {
    if (err instanceof Error && err.message.includes("already in use")) {
      throw new Error(`Nonce ${voucher.nonce} already settled. Use a fresh nonce.`);
    }
    throw err;
  }
}

try {
  await settleVoucher(program, voucher, settler);
} catch (err: unknown) {
  const msg = err instanceof Error ? err.message : String(err);

  if (msg.includes("already in use")) {
    console.error("Voucher already redeemed. Nonce:", voucher.nonce);
  } else if (msg.includes("InvalidSignature")) {
    console.error("Voucher signature invalid");
  } else if (msg.includes("EscrowExpired")) {
    console.error("Escrow expired. Call close_escrow to recover funds.");
  } else if (msg.includes("InsufficientFunds")) {
    console.error("Escrow underfunded for this voucher amount");
  } else {
    throw err;
  }
}

# Localnet
solana-test-validator --reset --quiet &
anchor test --skip-local-validator

# Devnet smoke
anchor test --skip-local-validator --skip-deploy --provider.cluster devnet

Online device          Offline device
──────────            ──────────────
TX → QR frames   →   Scan + reconstruct
                      ↓
Scan signature   ←   Sign → QR frames
↓
Submit to Solana

interface GrayBoxMetaAddress {
  spendPub: string; // base58 Ed25519 public key
  viewPub: string;  // base58 Ed25519 public key
}

interface StealthAddressResponse {
  stealthPubkey: string;   // base58 — send funds here
  ephemeralPub: string;    // needed for recipient to scan
  viewTag: number;         // single-byte scan optimization
}

interface ViewingKeyResponse {
  viewingKey: string;      // used for compliance scanning
}

# Demo API key (devnet only)
x-api-key: g-p_demo_h6kj9d8s7g6f5d4

# Production keys: hello@siriuslabs.tech

Base URL: https://graybox-cloak-production.up.railway.app

POST /v1/receiving-address
  Body: { spendPub: string, viewPub: string }
  Returns: StealthAddressResponse

POST /v1/compliance/viewing-key
  Headers: x-api-key
  Returns: ViewingKeyResponse

const GRAYBOX_URL = "https://graybox-cloak-production.up.railway.app";

// Derive a one-time stealth address for incoming payment
async function getStealthAddress(
  meta: GrayBoxMetaAddress,
  apiKey: string
): Promise<StealthAddressResponse> {
  const res = await fetch(`${GRAYBOX_URL}/v1/receiving-address`, {
    method: "POST",
    headers: { "x-api-key": apiKey, "Content-Type": "application/json" },
    body: JSON.stringify(meta),
  });
  if (!res.ok) {
    const text = await res.text();
    throw new Error(`GrayBox API error ${res.status}: ${text}`);
  }
  return res.json() as StealthAddressResponse;
}

// Generate a compliance viewing key (institutions / auditors)
async function getViewingKey(apiKey: string): Promise<ViewingKeyResponse> {
  const res = await fetch(`${GRAYBOX_URL}/v1/compliance/viewing-key`, {
    method: "POST",
    headers: { "x-api-key": apiKey },
  });
  if (!res.ok) {
    const text = await res.text();
    throw new Error(`GrayBox API error ${res.status}: ${text}`);
  }
  return res.json() as ViewingKeyResponse;
}

// Usage — stealth address
try {
  const { stealthPubkey } = await getStealthAddress(
    { spendPub: recipient.spendPub, viewPub: recipient.viewPub },
    "g-p_demo_h6kj9d8s7g6f5d4"
  );
  // stealthPubkey is now safe to use as the payment destination
} catch (err) {
  console.error("Failed to derive stealth address:", err);
}

// Generic interface — implement for any ZK shielded pool
interface ZkPoolAdapter {
  deposit(params: {
    amount: number;       // lamports
    recipient: string;    // stealth pubkey from GrayBox
  }): Promise<{ txSignature: string }>;

  withdraw(params: {
    amount: number;
    nullifier: string;    // spend nullifier
    proof: Uint8Array;    // Groth16 proof
  }): Promise<{ txSignature: string }>;
}

// components/SetupEscrow.tsx
"use client";

import { useWallet, useConnection } from "@solana/wallet-adapter-react";
import { AnchorProvider, Program, BN } from "@coral-xyz/anchor";
import { PublicKey } from "@solana/web3.js";
import { Buffer } from "buffer"; // npm install buffer
import idl from "./mora_idl.json";

const MORA_PROGRAM_ID = new PublicKey(
  "9fcXHD3pHDKLX79JuVgCEKQiqYkvVqFtpoAEVjBq4aJ8"
);

export function SetupEscrow() {
  const { connection } = useConnection();
  const wallet = useWallet();

  async function handleSetup() {
    if (!wallet.publicKey) return;

    const provider = new AnchorProvider(connection, wallet as any, {
      commitment: "confirmed",
    });
    const program = new Program(idl, MORA_PROGRAM_ID, provider);

    const seed = Date.now();
    const seedBuffer = Buffer.alloc(8);
    seedBuffer.writeBigUInt64LE(BigInt(seed));

    const [escrowPda] = PublicKey.findProgramAddressSync(
      [wallet.publicKey.toBuffer(), seedBuffer],
      MORA_PROGRAM_ID
    );

    await program.methods
      .createEscrow(new BN("2000000000")) // 2 SOL budget
      .accounts({ payer: wallet.publicKey, escrow: escrowPda })
      .rpc({ commitment: "confirmed" });

    console.log("Escrow funded:", escrowPda.toBase58());
    // Save escrowPda.toBase58() — needed for every voucher
  }

  return (
    <button
      onClick={handleSetup}
      style={{ padding: "8px 20px", borderRadius: "8px", background: "#1d4ed8", color: "#fff", fontWeight: 600, cursor: "pointer" }}
    >
      Fund Escrow
    </button>
  );
}

const API_KEY = "g-p_demo_h6kj9d8s7g6f5d4"; // devnet demo key

const { stealthPubkey } = await getStealthAddress(
  { spendPub: recipient.spendPub, viewPub: recipient.viewPub },
  API_KEY
);
// stealthPubkey — one-time address, safe to use as payment destination

import nacl from "tweetnacl"; // npm install tweetnacl
import { PublicKey, Keypair } from "@solana/web3.js";
import { Buffer } from "buffer"; // npm install buffer (browser polyfill)

// On air-gapped device — AirSign handles QR transport of keypair and message
// escrowPda: PublicKey from Step 1 | stealthPubkey: string from Step 2
// keypair: Keypair of the payer (never leaves the offline device)

const nonce = BigInt(1); // increment per payment
const lamports = BigInt(500_000_000); // 0.5 SOL

const nonceBuffer = Buffer.alloc(8);
nonceBuffer.writeBigUInt64LE(nonce);

const amountBuffer = Buffer.alloc(8);
amountBuffer.writeBigUInt64LE(lamports);

// 84-byte message: "MORA"(4) | escrow(32) | nonce(8) | payee(32) | amount(8)
const msg = Buffer.concat([
  Buffer.from("MORA"),
  escrowPda.toBuffer(),
  nonceBuffer,
  new PublicKey(stealthPubkey).toBuffer(),
  amountBuffer,
]);

const signature = nacl.sign.detached(msg, keypair.secretKey);
// AirSign encodes signature into fountain QR → online device scans

import { Buffer } from "buffer";

// Bob's online device received the signature from AirSign QR scan.

// Step 1: Settle the MORA voucher on-chain.
// Ed25519 native verify + lamport transfer are atomic in one tx.
// Bob (settler) calls this — not Alice.
try {
  const settleTx = await program.methods
    .settle(Buffer.from(signature))
    .accounts({ settler: wallet.publicKey, escrow: escrowPda })
    .rpc({ commitment: "confirmed" });

  console.log("MORA settled:", settleTx);
} catch (err: unknown) {
  const msg = err instanceof Error ? err.message : String(err);
  if (msg.includes("already in use")) {
    throw new Error("Voucher already redeemed. Use a fresh nonce.");
  }
  throw err;
}

// Step 2 (optional): Route through ZK shielded pool for full unlinkability.
// Funds have now arrived at the stealth address — deposit into pool from there.
// Skip this block if ZK is not required.
const { txSignature: poolTx } = await zkPool.deposit({
  amount: Number(lamports),
  recipient: stealthPubkey, // stealth address from GrayBox (Step 2)
});
console.log("Shielded deposit:", poolTx);