npm install @vara-eth/api viem@^2.39.0 [email protected]

import { VaraEthApi, WsVaraEthProvider, EthereumClient } from "@vara-eth/api";
import { walletClientToSigner } from "@vara-eth/api/signer";
import { createPublicClient, createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";

// Ethereum clients (viem)
const publicClient = createPublicClient({
  transport: http("https://hoodi-reth-rpc.gear-tech.io"),
});
const account = privateKeyToAccount("0x...");
const walletClient = createWalletClient({
  account,
  transport: http("https://hoodi-reth-rpc.gear-tech.io"),
});

// Convert viem WalletClient to ISigner
const signer = walletClientToSigner(walletClient);

// EthereumClient — wraps Router, Mirror, and wVARA contracts
const ethereumClient = new EthereumClient(
  publicClient,
  routerAddress,
  signer
);
await ethereumClient.waitForInitialization();

// VaraEthApi — connects to Vara.eth validator nodes
const api = new VaraEthApi(
  new WsVaraEthProvider("ws://localhost:9944"),
  ethereumClient
);

// Access contract clients
const router = ethereumClient.router; // RouterClient
const wvara = ethereumClient.wvara;   // WrappedVaraClient

const codeId = "0x..."; // From ethexe CLI upload

// Create program from validated code
const tx = await router.createProgram(codeId);
await tx.sendAndWaitForReceipt();
const programId = await tx.getProgramId();

// Or with Solidity ABI for Etherscan compatibility
const tx2 = await router.createProgramWithAbiInterface(codeId, abiAddress);
await tx2.sendAndWaitForReceipt();

import { getMirrorClient } from "@vara-eth/api";

const mirror = getMirrorClient(programId, signer, publicClient);

// Send message (payload encoded via sails-js)
const tx = await mirror.sendMessage(payload, 0n);
await tx.send();

// Get message details
const message = await tx.getMessage();
console.log("Message ID:", message.id);

// Wait for reply
const { waitForReply } = await tx.setupReplyListener();
const { payload: replyPayload, replyCode, value } = await waitForReply;

// Check wVARA balance
const balance = await wvara.balanceOf(ethereumClient.accountAddress);

// Approve program to spend wVARA
const approveTx = await wvara.approve(programId, BigInt(10 * 1e12));
await approveTx.sendAndWaitForReceipt();

// Top up program's Executable Balance
const topUpTx = await mirror.executableBalanceTopUp(BigInt(10 * 1e12));
const { status } = await topUpTx.sendAndWaitForReceipt();

// Code validation status
const codeState = await router.codeState(codeId);
// 'Validated' | 'Rejected' | 'Unknown'

// Program's code ID
const programCodeId = await router.programCodeId(programId);

// State hash from Mirror
const stateHash = await mirror.stateHash();

// Program nonce
const nonce = await mirror.nonce();

const tx = await router.createProgram(codeId);

// Send and get hash
const response = await tx.send();
console.log("Tx hash:", response.hash);

// Send and wait for receipt
const receipt = await tx.sendAndWaitForReceipt();

// Estimate gas
const gasEstimate = await tx.estimateGas();

// Find events in receipt
const event = await tx.findEvent("ProgramCreated");

import { VaraEthApi, WsVaraEthProvider, HttpVaraEthProvider } from "@vara-eth/api";

// WebSocket — for subscriptions and real-time updates
const api = new VaraEthApi(
  new WsVaraEthProvider("ws://localhost:9944"),
  ethereumClient
);

// HTTP — for one-time queries
const api = new VaraEthApi(
  new HttpVaraEthProvider("http://localhost:9944"),
  ethereumClient
);

// Disconnect when done
await api.provider.disconnect();

// Create injected transaction
const injected = await api.createInjectedTransaction({
  destination: programId,
  payload: encodedPayload,
  value: 0n,
  // Auto-populated if not provided:
  // recipient: validator address (auto-selected)
  // referenceBlock: recent Ethereum block hash
  // salt: random salt for uniqueness
});

// Send transaction
const result = await injected.send();

// Send and wait for promise (includes reply)
const promise = await injected.sendAndWaitForPromise();

// Validate the FROST threshold signature
await promise.validateSignature();

const injected = await api.createInjectedTransaction({
  destination: programId,
  payload: encodedPayload,
  value: 1000n,
  referenceBlock: blockHash,    // Specific Ethereum block
  salt: "0x030405",             // Custom salt
  recipient: validatorAddress,  // Specific validator
});

// Modify using fluent API
injected
  .setValue(2000n)
  .setSalt("0x060708");

// Access properties
const messageId = injected.messageId;

// Update fields
await injected.setReferenceBlock();     // Fetch latest block
await injected.setRecipient();          // Auto-select validator
await injected.setRecipient(address);   // Specific validator

// List all program IDs
const programIds = await api.query.program.getIds();

// Get program's code ID
const codeId = await api.query.program.codeId(programId);

// Read full program state by state hash
const stateHash = await mirror.stateHash();
const state = await api.query.program.readState(stateHash);

if ("Active" in state.program) {
  console.log("Program is active");
  console.log("Balance:", state.balance);
}

// Encode query payload using sails-js
const queryPayload = sails.services.Counter.queries.GetValue.encodePayload();

// Calculate reply (read-only, free)
const reply = await api.call.program.calculateReplyForHandle(
  await ethereumClient.getAccountAddress(), // Source address
  programId,                                 // Program to query
  queryPayload                               // Encoded query
);

// Decode result using sails-js
const value = sails.services.Counter.queries.GetValue.decodeResult(
  reply.payload
);
console.log("Current counter value:", value);

                    ┌──────────────────────┐
                    │     Your dApp        │
                    └──────┬───────┬───────┘
                           │       │
              Ethereum-side│       │Vara.eth-side
                           │       │
                    ┌──────▼──┐ ┌──▼──────────┐
                    │ Mirror  │ │  VaraEthApi  │
                    │Contract │ │  (direct)    │
                    └──────┬──┘ └──┬───────────┘
                           │       │
                    ┌──────▼───────▼──────────┐
                    │   Vara.eth Validators   │
                    │   (WASM execution)      │
                    └─────────┬───────────────┘
                              │
                    ┌─────────▼───────────────┐
                    │   Ethereum L1           │
                    │   (batch settlement)    │
                    └─────────────────────────┘

Ethereum RPC (L1): https://hoodi-reth-rpc.gear-tech.io
Vara.eth RPC:      http://127.0.0.1:9944
Vara.eth WS:       ws://127.0.0.1:9944