Quick Start

import * as anchor from "@anchor-lang/core";

// Initialize Anchor provider from environment variables
anchor.setProvider(anchor.AnchorProvider.env());
const provider = anchor.getProvider();

// Your MXE program ID
const programId = new anchor.web3.PublicKey("YourProgramIdHere");

import { getClusterAccAddress, getArciumEnv } from "@arcium-hq/client";

// Get cluster offset from environment (set by `arcium localnet` or your .env)
const arciumEnv = getArciumEnv();
const clusterAccount = getClusterAccAddress(arciumEnv.arciumClusterOffset);

import * as anchor from "@anchor-lang/core";
import { x25519, getMXEPublicKey, RescueCipher } from "@arcium-hq/client";
import { PublicKey } from "@solana/web3.js";

// Generate client keypair for encryption/decryption
// Note: In production, consider deriving this from your user keypair using signed message-based derivation
const clientPrivateKey = x25519.utils.randomSecretKey();
const clientPublicKey = x25519.getPublicKey(clientPrivateKey);

// Fetch MXE public key with retry logic
// → Expand "Helper Functions" accordion below for full implementation
const mxePublicKey = await getMXEPublicKeyWithRetry(
  provider as anchor.AnchorProvider,
  programId
);

// Derive shared secret and create cipher instance
const sharedSecret = x25519.getSharedSecret(clientPrivateKey, mxePublicKey);
const cipher = new RescueCipher(sharedSecret);

import { randomBytes } from "crypto";
import * as anchor from "@anchor-lang/core";
import { deserializeLE } from "@arcium-hq/client";

// Prepare your computation inputs
const inputs = [BigInt(42), BigInt(100)];

// Generate a 16-byte nonce
const nonce = randomBytes(16);

// Encrypt inputs - returns number[][] where ciphertext[i] corresponds to inputs[i]
// Each encrypted value is a 32-byte array
const ciphertext = cipher.encrypt(inputs, nonce);

// Generate unique computation offset (8 random bytes as identifier)
const computationOffset = new anchor.BN(randomBytes(8), "hex");

// Convert nonce to BN for Solana transaction serialization
const nonceBN = new anchor.BN(deserializeLE(nonce).toString());

import * as anchor from "@anchor-lang/core";
import { Program } from "@anchor-lang/core";
import { YourProgram } from "../target/types/your_program";

// Load your Anchor program using workspace pattern
const program = anchor.workspace.YourProgram as Program<YourProgram>;

// Type-safe event listener helper
type Event = anchor.IdlEvents<(typeof program)["idl"]>;

const awaitEvent = async <E extends keyof Event>(eventName: E): Promise<Event[E]> => {
  let listenerId: number;
  const event = await new Promise<Event[E]>((res) => {
    listenerId = program.addEventListener(eventName, (event) => {
      res(event);
    });
  });
  await program.removeEventListener(listenerId);
  return event;
};

// Set up event listener BEFORE submitting transaction
const resultEventPromise = awaitEvent("yourResultEvent");

import * as anchor from "@anchor-lang/core";
import {
  getComputationAccAddress,
  getMXEAccAddress,
  getMempoolAccAddress,
  getExecutingPoolAccAddress,
  getCompDefAccAddress,
  getCompDefAccOffset,
} from "@arcium-hq/client";

// From previous steps:
// - provider, programId (Step 1)
// - arciumEnv, clusterAccount (Step 2)
// - clientPublicKey (Step 3)
// - computationOffset, ciphertext, nonceBN (Step 4)
// - program, resultEventPromise (Step 5)

// Get computation definition offset for your encrypted instruction
// The instruction name must match the function name in your Rust MXE program
// (e.g., if your function is `add_together`, use "add_together")
const compDefIndex = Buffer.from(getCompDefAccOffset("your_instruction_name")).readUInt32LE();

// Submit the computation transaction
const signature = await program.methods
  .yourComputationMethod(
    computationOffset,
    Array.from(ciphertext[0]),
    Array.from(ciphertext[1]),
    Array.from(clientPublicKey),
    nonceBN
  )
  .accountsPartial({
    computationAccount: getComputationAccAddress(arciumEnv.arciumClusterOffset, computationOffset),
    clusterAccount,
    mxeAccount: getMXEAccAddress(programId),
    mempoolAccount: getMempoolAccAddress(arciumEnv.arciumClusterOffset),
    executingPool: getExecutingPoolAccAddress(arciumEnv.arciumClusterOffset),
    compDefAccount: getCompDefAccAddress(programId, compDefIndex),
    // ... your program-specific accounts
  })
  .rpc({ skipPreflight: true, commitment: "confirmed" });

console.log("Computation submitted:", signature);

import * as anchor from "@anchor-lang/core";
import { awaitComputationFinalization } from "@arcium-hq/client";

// Wait for computation finalization
const finalizationSignature = await awaitComputationFinalization(
  provider as anchor.AnchorProvider,
  computationOffset,
  programId,
  "confirmed"
);

console.log("Computation finalized:", finalizationSignature);

// Await the event (listener was set up in Step 5)
const resultEvent = await resultEventPromise;

// Decrypt the result
// The result uses nonce + 1 (nonces must be unique per operation)
const resultNonce = Uint8Array.from(resultEvent.nonce);  // Convert from number[]
const decryptedResult = cipher.decrypt([resultEvent.encryptedResult], resultNonce)[0];

console.log("Decrypted result:", decryptedResult);