Be One of Us.
Let's make Ethereum run real programs

cargo build --release

target/wasm32-gear/release/*.opt.wasm

cargo sails sol --idl-path ./target/wasm32-gear/release/one_of_us.idl

# Clone the gear repo, then build the CLI
git clone https://github.com/gear-tech/gear.git
cargo build -p ethexe-cli -r

./target/release/ethexe key insert $SENDER_PRIVATE_KEY

./target/release/ethexe --cfg none tx \
  --ethereum-rpc "wss://hoodi-reth-rpc.gear-tech.io/ws" \
  --ethereum-router "0xBC888a8B050B9B76a985d91c815d2c4f2131a58A" \
  --sender "$SENDER_ADDRESS" \
  upload target/wasm32-gear/release/one_of_us.opt.wasm -w

Transaction: 0xe5d6515879c6b1b3c0fe52981968e736595b5dedb0cecd2760966ed9c9030636
Code ID: 0x59810e0b451a041adff0fe2e551430186c664e2a97c80a80154003b74dd8829d

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

const hoodi = defineChain({
  id: 560048,
  name: "Hoodi Testnet",
  network: "hoodi",
  nativeCurrency: {decimals: 18, name: "Ether", symbol: "ETH"},
  rpcUrls: {default: {http: [ETH_RPC]}},
  testnet: true,
});

async function main() {
  const account = privateKeyToAccount(PRIVATE_KEY);

  const publicClient = createPublicClient({
    chain: hoodi,
    transport: http(ETH_RPC),
  });
  const walletClient = createWalletClient({
    account,
    chain: hoodi,
    transport: http(ETH_RPC),
  });

  // Setup Vara.eth client
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;
  const router = ethereumClient.router;

  // Create program instance
  const tx = await router.createProgram(CODE_ID);
  const receipt = await tx.sendAndWaitForReceipt();

  // Get the program ID (Mirror address)
  const programId = await tx.getProgramId();
  console.log("Program ID:", programId);
}

# Install Foundry
curl -L https://foundry.paradigm.xyz | bash
foundryup

# Install dependencies (from project root)
forge install

cargo sails sol --idl-path ./target/wasm32-gear/release/one_of_us.idl

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.28;

import {Script, console} from "forge-std/Script.sol";
import {OneOfUsAbi} from "../OneOfUs.sol";

contract DeployOneOfUsAbi is Script {
    function run() external returns (address) {
        bytes32 pkBytes = vm.envBytes32("PRIVATE_KEY");
        uint256 deployerPrivateKey = uint256(pkBytes);

        vm.startBroadcast(deployerPrivateKey);

        OneOfUsAbi abiContract = new OneOfUsAbi();
        console.log("OneOfUsAbi deployed at:", address(abiContract));

        vm.stopBroadcast();
        return address(abiContract);
    }
}

import {execSync} from "child_process";
import {EthereumClient} from "@vara-eth/api";

function deployWithForge(): string {
  const etherscanKey = process.env.ETHERSCAN_API_KEY;
  const verifyFlag = etherscanKey
    ? `--verify --etherscan-api-key ${etherscanKey}`
    : "";

  const output = execSync(
    `forge script deploy/DeployOneOfUsAbi.s.sol:DeployOneOfUsAbi \
      --rpc-url ${ETH_RPC} \
      --broadcast ${verifyFlag} -vvv`,
    {cwd: projectRoot, encoding: "utf-8"}
  );

  // Parse deployed address from output
  const match = output.match(/deployed at:\s*(0x[a-fA-F0-9]{40})/i);
  return match[1];
}

async function main() {
  // Step 1: Deploy ABI contract with Foundry
  const abiAddress = deployWithForge();
  console.log("ABI Contract deployed:", abiAddress);

  // Step 2: Create program with ABI interface
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;

  const tx = await ethereumClient.router.createProgramWithAbiInterface(
    CODE_ID,
    abiAddress
  );
  const receipt = await tx.sendAndWaitForReceipt();
  const programId = await tx.getProgramId();

  console.log("Program ID:", programId);
}

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

async function main() {
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;
  const wvara = ethereumClient.wvara;
  const mirror = getMirrorClient(PROGRAM_ID, walletClient, publicClient);

  const amount = BigInt(10_000_000_000_000); // 10 wVARA

  // Step 1: Approve wVARA for the program to spend
  const approveTx = await wvara.approve(PROGRAM_ID, amount);
  await approveTx.sendAndWaitForReceipt();

  // Step 2: Top up executable balance via Mirror
  const topUpTx = await mirror.executableBalanceTopUp(amount);
  await topUpTx.sendAndWaitForReceipt();
}

import {EthereumClient, getMirrorClient} from "@vara-eth/api";
import {Sails} from "sails-js";
import {SailsIdlParser} from "sails-js-parser";

async function main() {
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;
  const mirror = getMirrorClient(PROGRAM_ID, walletClient, publicClient);

  // Initialize Sails from your program IDL
  const parser = await SailsIdlParser.new();
  const sails = new Sails(parser);
  sails.parseIdl(readFileSync("./one_of_us.idl", "utf-8"));

  // Encode a regular call using ABI/IDL
  const payload = sails.services.OneOfUs.functions.JoinUs.encodePayload();

  // Send through Ethereum to Mirror
  const tx = await mirror.sendMessage(payload, 0n);
  const receipt = await tx.sendAndWaitForReceipt();

  // Wait for the program reply
  const {waitForReply} = await tx.setupReplyListener();
  const {payload: replyPayload} = await waitForReply;

  // Decode result
  const result =
    sails.services.OneOfUs.functions.JoinUs.decodeResult(replyPayload);
}

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

async function main() {
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;

  // Connect to Vara.eth network via WebSocket
  const api = new VaraEthApi(
    new WsVaraEthProvider(VARA_ETH_WS),
    ethereumClient
  );

  // Encode the call
  const payload = sails.services.OneOfUs.functions.JoinUs.encodePayload();

  // Build an injected tx (off-chain pre-confirmation path)
  const injected = await api.createInjectedTransaction({
    destination: PROGRAM_ID,
    payload: payload,
    value: 0n,
  });

  // Wait for full transaction promise (includes reply)
  const result = await injected.sendAndWaitForPromise();
  // Result contains 'Accept' or 'Reject' status with reply payload
}

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

async function main() {
  const ethereumClient = new EthereumClient(
    publicClient,
    walletClient,
    ROUTER_ADDRESS
  );
  await ethereumClient.isInitialized;
  const mirror = getMirrorClient(PROGRAM_ID, walletClient, publicClient);

  // Connect to Vara.eth API
  const api = new VaraEthApi(
    new WsVaraEthProvider(VARA_ETH_WS),
    ethereumClient
  );

  // Get the current state hash from Ethereum (Mirror contract)
  const stateHash = await mirror.stateHash();

  // Query: How many builders joined?
  const countPayload = sails.services.OneOfUs.queries.Count.encodePayload();

  const countReply = await api.call.program.calculateReplyForHandle(
    account.address,
    PROGRAM_ID,
    countPayload
  );

  const count = sails.services.OneOfUs.queries.Count.decodeResult(
    countReply.payload
  );
  console.log("Builders count:", count);

  // Query: Who are the builders? (paginated)
  const buildersPayload = sails.services.OneOfUs.queries.List.encodePayload(
    0,
    100
  ); // page 0, 100 items

  const buildersReply = await api.call.program.calculateReplyForHandle(
    account.address,
    PROGRAM_ID,
    buildersPayload
  );

  const builders = sails.services.OneOfUs.queries.List.decodeResult(
    buildersReply.payload
  );
  console.log("Builders list:", builders);
}