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, Idl, Program } from "@coral-xyz/anchor";
import { useConnection, useWallet } from "@solana/wallet-adapter-react";
import idl from "./mora.json"; // IDL from the MORA repo (see Installation)

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 as Idl, provider); // program ID comes from the IDL
  }, [connection, wallet]);
}

accept offline  ⇔  Ed25519 signature valid
                   ∧ escrow = PDA("escrow", authority, seed)
                   ∧ amount ≤ escrow amount at creation
                   ∧ amount ≤ receiver's offline limit
                   ∧ now < expires_at

accept online   ⇔  the same checks against the live escrow
                   ∧ amount ≤ escrow.amount − escrow.spent
                   ∧ no Receipt PDA for this nonce yet

on-chain        ⇒  Σ settled ≤ escrow.amount   (always)

receiver's worst case  ≤  offline limit × vouchers accepted before reconnecting

npm install @coral-xyz/anchor @solana/web3.js tweetnacl
# Download the IDL and save it as mora.json:
# https://github.com/sirius-labs-dev/mora/blob/main/landing/public/demo/mora.json

import {
  buildVoucherMessage, encodeVoucherQr, escrowPda,
  decodeVoucherQr, verifyVoucherOffline, settleIxs,
} from "@mora/sdk";

// Payer, offline: an Ed25519 signature over 84 bytes, no RPC
const escrow = escrowPda(payer.publicKey, seed);
const message = buildVoucherMessage({ escrow, nonce, payee, amount });
const signature = nacl.sign.detached(message, payer.secretKey);
const qr = encodeVoucherQr({ message, signature },
  { authority: payer.publicKey, seed, expiresAt, escrowAmount });

// Receiver: check offline, settle once back online
const voucher = decodeVoucherQr(qr);
const check = verifyVoucherOffline(voucher);
if (!check.ok) throw new Error(check.reason);
const tx = new Transaction().add(
  ...settleIxs(receiver.publicKey, voucher.meta!.authority, voucher));

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

interface MoraVoucher {
  escrow: PublicKey;
  nonce: bigint;         // u64, unique per payment
  payee: PublicKey;
  amount: bigint;        // lamports (u64)
  message: Uint8Array;   // the 84 signed bytes
  signature: Uint8Array; // 64-byte Ed25519 sig
}

// On-chain Escrow account, as returned by program.account.escrow.fetch()
interface EscrowAccount {
  authority: PublicKey;  // the payer, who signs vouchers
  seed: BN;
  amount: BN;            // lamports locked
  spent: BN;             // lamports already settled
  expiresAt: BN;         // unix seconds
  bump: number;
}

import { PublicKey } from "@solana/web3.js";
import { Buffer } from "buffer";

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

const u64le = (n: bigint) => {
  const b = Buffer.alloc(8);
  b.writeBigUInt64LE(n);
  return b;
};

// Seeds: "escrow" | authority | seed (u64 LE)
function deriveEscrowPda(authority: PublicKey, seed: bigint): PublicKey {
  const [escrowPda] = PublicKey.findProgramAddressSync(
    [Buffer.from("escrow"), authority.toBuffer(), u64le(seed)],
    MORA_PROGRAM_ID
  );
  return escrowPda;
}

// Seeds: "receipt" | escrow | nonce (u64 LE). One per settled voucher.
function deriveReceiptPda(escrow: PublicKey, nonce: bigint): PublicKey {
  const [receiptPda] = PublicKey.findProgramAddressSync(
    [Buffer.from("receipt"), escrow.toBuffer(), u64le(nonce)],
    MORA_PROGRAM_ID
  );
  return receiptPda;
}

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 { Ed25519Program, Keypair, PublicKey, Transaction } from "@solana/web3.js";
import { Buffer } from "buffer"; // npm install buffer
import nacl from "tweetnacl";
// MoraVoucher: see TypeScript Types. u64le, deriveEscrowPda, deriveReceiptPda:
// see Escrow PDA Derivation. program: see useMoraProgram (Wallet Setup).

async function createEscrow(
  program: Program,
  authority: PublicKey,
  lamports: bigint,
  expiresInSeconds: number
): Promise<{ escrow: PublicKey; seed: bigint }> {
  const seed = BigInt(Date.now()); // any unique u64 per escrow
  const expiresAt = Math.floor(Date.now() / 1000) + expiresInSeconds;

  await program.methods
    .createEscrow(new BN(seed.toString()), new BN(lamports.toString()), new BN(expiresAt))
    .accounts({ authority })
    .rpc();

  return { escrow: deriveEscrowPda(authority, seed), seed };
}

function signVoucher(
  escrow: PublicKey,
  nonce: bigint,
  payee: PublicKey,
  amount: bigint,
  keypair: Keypair
): MoraVoucher {
  const message = Buffer.concat([
    Buffer.from("MORA"),
    escrow.toBuffer(),
    u64le(nonce),
    payee.toBuffer(),
    u64le(amount),
  ]); // 84 bytes

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

async function settleVoucher(
  program: Program,
  voucher: MoraVoucher,
  payer: PublicKey // escrow authority, the voucher signer
): Promise<string> {
  // The Ed25519 verify instruction must come right before settle.
  const verifyIx = Ed25519Program.createInstructionWithPublicKey({
    publicKey: payer.toBytes(),
    message: voucher.message,
    signature: voucher.signature,
  });
  const settleIx = await program.methods
    .settle(new BN(voucher.nonce.toString()), new BN(voucher.amount.toString()))
    .accountsPartial({
      submitter: program.provider.publicKey!, // anyone can submit
      escrow: voucher.escrow,
      payee: voucher.payee,
      receipt: deriveReceiptPda(voucher.escrow, voucher.nonce),
    })
    .instruction();

  const provider = program.provider as AnchorProvider;
  try {
    return await provider.sendAndConfirm(new Transaction().add(verifyIx, settleIx));
  } 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;
  }
}

// What is still payable from an escrow, and until when
async function escrowBalance(program: Program, escrow: PublicKey) {
  const info = await program.provider.connection.getAccountInfo(escrow);
  if (!info) throw new Error("Escrow not found: it may already be closed");
  const e = program.coder.accounts.decode("escrow", info.data);
  const remaining = BigInt(e.amount.toString()) - BigInt(e.spent.toString());
  const expiresAt = Number(e.expiresAt.toString());
  return { remaining, expiresAt, expired: Date.now() / 1000 >= expiresAt };
}

// The payer reclaims the unspent remainder and rent
async function closeEscrow(program: Program, authority: PublicKey, escrow: PublicKey) {
  // Only after expires_at; otherwise the program returns NotExpired.
  return program.methods
    .closeEscrow()
    .accountsPartial({ authority, escrow })
    .rpc();
}

try {
  await settleVoucher(program, voucher, payer);
} 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("SignerMismatch") || msg.includes("MsgMismatch")) {
    console.error("Voucher not signed by the escrow owner, or bytes altered");
  } else if (msg.includes("Expired")) {
    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
}

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

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

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 as Idl, provider);

    const seed = new BN(Date.now());
    const expiresAt = new BN(Math.floor(Date.now() / 1000) + 7 * 24 * 3600); // 7 days

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

    const [escrowPda] = PublicKey.findProgramAddressSync(
      [Buffer.from("escrow"), wallet.publicKey.toBuffer(), seed.toArrayLike(Buffer, "le", 8)],
      program.programId
    );
    console.log("Escrow funded:", escrowPda.toBase58());
    // Save escrowPda and seed: every voucher names the escrow
  }

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

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: PublicKey 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,
  stealthPubkey.toBuffer(),
  amountBuffer,
]);

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

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

// Bob's online device received msg + signature from the AirSign QR scan.
// alicePubkey: escrow authority | nonce, lamports: from Step 3

const [receiptPda] = PublicKey.findProgramAddressSync(
  [Buffer.from("receipt"), escrowPda.toBuffer(), nonceBuffer],
  program.programId
);

// Ed25519 native verify + settle are atomic in one tx.
// Anyone can submit: here Bob pays the fee.
const settleIx = await program.methods
  .settle(new BN(nonce.toString()), new BN(lamports.toString()))
  .accountsPartial({
    submitter: wallet.publicKey,
    escrow: escrowPda,
    payee: stealthPubkey,
    receipt: receiptPda,
  })
  .instruction();

try {
  const settleTx = await provider.sendAndConfirm(new Transaction().add(
    Ed25519Program.createInstructionWithPublicKey({
      publicKey: alicePubkey.toBytes(),
      message: msg,
      signature,
    }),
    settleIx
  ));
  console.log("MORA settled:", settleTx);
} catch (err: unknown) {
  const m = err instanceof Error ? err.message : String(err);
  if (m.includes("already in use")) {
    throw new Error("Voucher already redeemed. Use a fresh nonce.");
  }
  throw err;
}