Quick Start

import * as anchor from "@coral-xyz/anchor";

// 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";

// For localnet: null (reads ARCIUM_CLUSTER_PUBKEY from environment)
// For devnet/testnet: your cluster offset (see callout below)
const CLUSTER_OFFSET: number | null = null;

const clusterAccount =
  CLUSTER_OFFSET !== null
    ? getClusterAccAddress(CLUSTER_OFFSET)
    : getArciumEnv().arciumClusterPubkey;

import * as anchor from "@coral-xyz/anchor";
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 "@coral-xyz/anchor";
import { deserializeLE } from "@arcium-hq/client";

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

// Generate a 16-byte nonce (required)
const nonce = randomBytes(16); // Must be exactly 16 bytes

// Encrypt inputs - returns number[][] where each element is a 32-byte ciphertext
const ciphertext = cipher.encrypt(inputs, nonce);

// Generate computation offset and convert nonce to BN for transaction
const computationOffset = new anchor.BN(randomBytes(8), "hex");
const nonceBN = new anchor.BN(deserializeLE(nonce).toString());

import * as anchor from "@coral-xyz/anchor";

// Load your Anchor program
const program = new anchor.Program(
  YourProgramIdl, // Your program's IDL
  programId,
  provider
);

// Type-safe event listener helper
// → Expand "Helper Functions" accordion below for full implementation
type Event = anchor.IdlEvents<typeof program.idl>;

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

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

// From previous steps:
// - provider, programId (Step 1)
// - clusterAccount (Step 2)
// - clusterOffset (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 compDefOffset = getCompDefAccOffset("your_instruction_name");
const compDefIndex = Buffer.from(compDefOffset).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(clusterOffset, computationOffset),
    clusterAccount,
    mxeAccount: getMXEAccAddress(programId),
    mempoolAccount: getMempoolAccAddress(clusterOffset),
    executingPool: getExecutingPoolAccAddress(clusterOffset),
    compDefAccount: getCompDefAccAddress(programId, compDefIndex),
    // ... your program-specific accounts
  })
  .rpc({ skipPreflight: true, commitment: "confirmed" });

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

import * as anchor from "@coral-xyz/anchor";
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);

import * as anchor from "@coral-xyz/anchor";

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

// Decrypt the result using the cipher and event nonce
const [decryptedResult] = cipher.decrypt(
  [resultEvent.encryptedResult],
  new Uint8Array(resultEvent.nonce)
);

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