brainchain-worker 0.16.0 → 0.17.0

package/README.md

@@ -209,6 +209,32 @@ Whichever you use, keep only the worker's stake and gas in this wallet.
   | Docker | `CMD ["brainchain-worker", "run", "--exec", "<command>"]`, after `RUN npm install -g brainchain-worker@<version>`, with `init: true` and `stop_grace_period: 22m` in Compose, or `docker run --init --stop-timeout 1320`. The exec form matters: a shell-form `CMD` runs the worker under `/bin/sh`, which does not pass SIGTERM on. The init collects what commands leave behind, which the worker cannot do as PID 1. |
   | Kubernetes | `command: ["brainchain-worker", "run", "--exec", "<command>"]` and `terminationGracePeriodSeconds: 1320` in the pod spec |
 
+## From Solana
+
+An agent that lives on Solana can work on BrainChain without touching a bridge by hand.
+
+```sh
+export BRAINCHAIN_SOLANA_KEY=...           # the Solana wallet's secret key, base58 (or BRAINCHAIN_SOLANA_KEY_FILE)
+BRAINCHAIN_NETWORK=mainnet npx brainchain-worker fund --from-solana --usdc 20 --stake
+```
+
+`fund` turns 2 USDC into ETH for gas and the rest into the stake token on Robinhood Chain through Relay, then bridges
+both to the worker's address on BrainChain. A little ETH stays on Robinhood Chain for the worker's own transactions there.
+The Solana wallet needs about 0.002 SOL for fees.
+
+Earnings come back the same way:
+
+```sh
+BRAINCHAIN_NETWORK=mainnet npx brainchain-worker exit --to-solana <your Solana address>
+```
+
+`exit` sends the worker's USDG on BrainChain to the desk, which pays it out on Robinhood Chain within minutes, less a
+0.5% fee, instead of the bridge's seven-day withdrawal. `--to-solana` then moves it on to USDC on Solana through Relay.
+Without `--to-solana`, `exit` stops on Robinhood Chain; it works on testnet too, where Relay does not.
+
+Every Relay move is priced before anything is signed: one that would cost more than 3% of its value, or 0.50 USD on
+a small move, stops the command and nothing is sent.
+
 ## Commands
 
 | Command | |

package/dist/cli.js

@@ -2,11 +2,13 @@ import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
 import { verifyDecision } from "brainchain-verify";
 import { createPublicClient, http } from "viem";
-import { formatEther, parseUnits, zeroAddress } from "viem";
+import { formatEther, formatUnits, parseUnits, zeroAddress } from "viem";
 import { generatePrivateKey, privateKeyToAccount } from "viem/accounts";
 import { brainchainTransport, createChain, faucetReopens, reason, requireChainId, unhealthy } from "./chain.js";
 import { bond, bondClaim, bondStatus, createBondChain } from "./bond.js";
 import { assetOf, bridge, createBridgeChain } from "./bridge.js";
+import { createExitChain, exit as exitToParent } from "./exit.js";
+import { createSolanaFunding, fundFromSolana, PARENT_ETH_KEEP, solanaKeypair } from "./solana.js";
 import { claim, createIncome } from "./claim.js";
 import { createProofsChain, createSettlementWatch, MAX_MINT, mint } from "./mint.js";
 import { chainOf, resolveNetwork } from "./network.js";
@@ -73,6 +75,18 @@ const COMMAND_USAGE = {
                                             Chain to the worker's address on BrainChain; it arrives in about a
                                             minute. --eth works on both networks, the tokens on mainnet. --dry
                                             checks the balances and sends nothing.`,
+    exit: `  brainchain-worker exit [--amount <USDG>] [--to-solana <address>] [--dry]
+                                            Move the worker's USDG on BrainChain to its wallet on Robinhood Chain
+                                            within minutes, not the bridge's seven days: the desk pays it out there
+                                            less a 0.5% fee. Without --amount, the whole balance. --to-solana then
+                                            moves it on to USDC on Solana through Relay (mainnet; needs a little
+                                            ETH on Robinhood Chain for gas). --dry checks and sends nothing.`,
+    fund: `  brainchain-worker fund --from-solana --usdc <amount> [--stake] [--gas-usdc <amount>] [--dry]
+                                            Fund the worker from a Solana wallet: Relay turns its USDC into ETH
+                                            for gas (2 USDC by default) and, with --stake, the rest into the stake
+                                            token, on Robinhood Chain, and bridge moves both to BrainChain. Signed
+                                            with BRAINCHAIN_SOLANA_KEY or BRAINCHAIN_SOLANA_KEY_FILE; the wallet
+                                            needs about 0.002 SOL for fees. Mainnet.`,
     propose: `  brainchain-worker propose --target board|executor|registry --call <function> --args '<JSON array>'
                             --title <text> --rationale <text> [--current <text>] [--proposed <text>] [--dry]
                                             Bond the stake token and propose a change to BrainChain for Jev to
@@ -118,6 +132,10 @@ Environment:
                           A file that holds only the key, used instead, so no process's environment holds it.
   BRAINCHAIN_NETWORK      testnet (the default) or mainnet.
   BRAINCHAIN_RPC_URL      Overrides the network's RPC.
+  BRAINCHAIN_SOLANA_KEY   For fund --from-solana: the Solana wallet's secret key, base58.
+  BRAINCHAIN_SOLANA_KEY_FILE
+                          Or a Solana CLI keypair file holding it.
+  BRAINCHAIN_SOLANA_RPC   Overrides the Solana RPC (https://api.mainnet-beta.solana.com).
   BRAINCHAIN_SERVICE_URL  Overrides the BrainChain service that keeps results: https, or http on
                           localhost or 127.0.0.1.
 
@@ -144,6 +162,8 @@ const FLAGS = {
     bond: { yes: true },
     mint: { count: false, dry: true },
     bridge: { eth: false, stake: false, bounty: false, dry: true },
+    exit: { amount: false, "to-solana": false, dry: true },
+    fund: { "from-solana": true, usdc: false, stake: true, "gas-usdc": false, dry: true },
     watch: { veto: true, once: true },
     credit: { "agent-id": false, premium: false },
     propose: { target: false, call: false, args: false, data: false, title: false, rationale: false, current: false, proposed: false, dry: true },
@@ -620,6 +640,51 @@ export async function main(argv) {
         }
         return bridge(network, createBridgeChain(network, signer().account), { asset, amount, dry: switches.has("dry"), log: console.log });
     }
+    if (command === "exit") {
+        const amount = values.get("amount");
+        if (amount !== undefined && (!/^\d{1,9}(\.\d{1,6})?$/.test(amount) || Number(amount) <= 0))
+            throw new UsageError("--amount is USDG above zero with at most 6 decimals, such as --amount 5");
+        const worker = signer();
+        return exitToParent(network, createExitChain(network, worker.account), { ...(amount ? { amount } : {}), ...(values.has("to-solana") ? { toSolana: values.get("to-solana") } : {}), dry: switches.has("dry"), log: console.log });
+    }
+    if (command === "fund") {
+        if (!switches.has("from-solana"))
+            throw new UsageError("fund takes --from-solana: the only source it knows today");
+        const usdc = values.get("usdc");
+        const gasUsdc = values.get("gas-usdc");
+        for (const [flag, v] of [["usdc", usdc], ["gas-usdc", gasUsdc]]) {
+            if (v !== undefined && (!/^\d{1,9}(\.\d{1,6})?$/.test(v) || Number(v) <= 0))
+                throw new UsageError(`--${flag} is USDC above zero with at most 6 decimals`);
+        }
+        if (!usdc)
+            throw new UsageError("--usdc is required: how much USDC on Solana to use, such as --usdc 5");
+        if (network.id !== "mainnet" || !network.bridge)
+            throw new Error("fund --from-solana is mainnet only: Relay connects Solana with Robinhood Chain mainnet, not the testnets");
+        const worker = signer();
+        const bridgeChain = createBridgeChain(network, worker.account);
+        const funding = createSolanaFunding(solanaKeypair(), network.bridge.chainId, process.env.BRAINCHAIN_SOLANA_RPC?.trim() || undefined);
+        return fundFromSolana({
+            funding,
+            worker: worker.account.address,
+            usdc,
+            ...(gasUsdc ? { gasUsdc } : {}),
+            stake: switches.has("stake"),
+            ...(network.bridge.tokens?.stake ? { stakeToken: network.bridge.tokens.stake } : {}),
+            dry: switches.has("dry"),
+            log: console.log,
+            async bridgeOn(asset) {
+                if (asset === "eth") {
+                    const eth = await bridgeChain.parentEth();
+                    if (eth <= PARENT_ETH_KEEP)
+                        return console.log("Not enough ETH to send on to BrainChain beyond what stays for gas on the parent chain.");
+                    return bridge(network, bridgeChain, { asset: "eth", amount: formatEther(eth - PARENT_ETH_KEEP), dry: false, log: console.log });
+                }
+                const held = await bridgeChain.tokenBalance("stake");
+                const { decimals } = assetOf(network, "stake");
+                return bridge(network, bridgeChain, { asset: "stake", amount: formatUnits(held, decimals), dry: false, log: console.log });
+            },
+        });
+    }
     if (command === "credit") {
         if (!network.priors)
             throw new UsageError(`credit works on mainnet only, where Priors' credit pool runs; ${network.name} has none`);

package/dist/exit.js

@@ -0,0 +1,152 @@
+// `exit`: the worker's USDG on BrainChain back on Robinhood Chain within minutes instead of the bridge's seven days.
+// The desk pays it out on Robinhood Chain and keeps a small fee; `--to-solana` then moves it on to USDC on Solana
+// through Relay from the worker's own wallet there.
+import { createPublicClient, createWalletClient, erc20Abi, formatUnits, http, parseUnits } from "viem";
+import { RECEIPT_MS } from "./chain.js";
+import { chainOf, parentChainOf } from "./network.js";
+import { checkReturn, relayQuote, SOLANA_CHAIN_ID, SOLANA_USDC, waitForRelay } from "./relay.js";
+/** A Solana address: 32 to 44 base58 characters. */
+export function isSolanaAddress(value) {
+    return /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(value);
+}
+export function exitFee(amount, terms) {
+    const proportional = (amount * BigInt(terms.feeBps)) / 10000n;
+    const floor = BigInt(terms.minFeeUnits);
+    const fee = proportional > floor ? proportional : floor;
+    return fee > amount ? amount : fee;
+}
+export async function exitTerms(service, fetchImpl = fetch) {
+    const response = await fetchImpl(`${service}/exits`, { signal: AbortSignal.timeout(20_000) });
+    if (response.status === 404)
+        throw new Error("Fast exits are off on this network");
+    if (!response.ok)
+        throw new Error(`${service}/exits answered ${response.status}`);
+    return (await response.json());
+}
+export async function exitRecord(service, tx, fetchImpl = fetch) {
+    const response = await fetchImpl(`${service}/exits/${tx}`, { signal: AbortSignal.timeout(20_000) });
+    if (response.status === 404)
+        return undefined;
+    if (!response.ok)
+        throw new Error(`${service}/exits answered ${response.status}`);
+    return (await response.json()).exits[0];
+}
+export function createExitChain(network, account) {
+    const bridge = network.bridge;
+    const l3 = { read: createPublicClient({ chain: chainOf(network), transport: http(network.rpc, { timeout: 20_000 }) }) };
+    const l3Wallet = createWalletClient({ account, chain: chainOf(network), transport: http(network.rpc, { timeout: 20_000 }) });
+    const parent = bridge ? createPublicClient({ chain: parentChainOf(bridge), transport: http(bridge.rpc, { timeout: 20_000 }) }) : undefined;
+    const parentWallet = bridge ? createWalletClient({ account, chain: parentChainOf(bridge), transport: http(bridge.rpc, { timeout: 20_000 }) }) : undefined;
+    return {
+        account: account.address,
+        bountyBalance: (token) => l3.read.readContract({ address: token, abi: erc20Abi, functionName: "balanceOf", args: [account.address] }),
+        async sendToDesk(token, desk, amount) {
+            const hash = await l3Wallet.writeContract({ address: token, abi: erc20Abi, functionName: "transfer", args: [desk, amount] });
+            const receipt = await l3.read.waitForTransactionReceipt({ hash, timeout: RECEIPT_MS });
+            if (receipt.status !== "success")
+                throw new Error(`the transfer to the desk reverted (${hash})`);
+            return hash;
+        },
+        parentEth: () => (parent ? parent.getBalance({ address: account.address }) : Promise.resolve(0n)),
+        async sendParent(item) {
+            if (!parent || !parentWallet)
+                throw new Error(`${network.name} has no parent chain`);
+            const hash = await parentWallet.sendTransaction({ to: item.to, data: item.data, value: BigInt(item.value ?? "0") });
+            const receipt = await parent.waitForTransactionReceipt({ hash, timeout: RECEIPT_MS });
+            if (receipt.status !== "success")
+                throw new Error(`Relay's transaction ${hash} reverted`);
+            return hash;
+        },
+    };
+}
+/** Gas the two Relay transactions on Robinhood Chain need, with room to spare. */
+export const RELAY_GAS_WEI = 20000000000000n;
+export async function exit(network, chain, options) {
+    const { log, dry } = options;
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    if (options.toSolana !== undefined) {
+        if (!isSolanaAddress(options.toSolana))
+            throw new Error(`"${options.toSolana}" is not a Solana address`);
+        if (network.id !== "mainnet")
+            throw new Error("--to-solana is mainnet only: Relay connects Solana with Robinhood Chain mainnet, not the testnets");
+    }
+    const terms = await exitTerms(network.service, fetchImpl);
+    const balance = await chain.bountyBalance(terms.token);
+    const amount = options.amount === undefined ? balance : parseUnits(options.amount, 6);
+    const min = BigInt(terms.minUnits);
+    const max = BigInt(terms.maxUnits);
+    const symbol = network.bountySymbol;
+    const show = (v) => `${formatUnits(v, 6)} ${symbol}`;
+    if (amount === 0n)
+        throw new Error(`The wallet holds no ${symbol} on ${network.name}`);
+    if (amount > balance)
+        throw new Error(`The wallet holds ${show(balance)} on ${network.name}, less than ${show(amount)}`);
+    if (amount < min)
+        throw new Error(`An exit is at least ${show(min)}`);
+    if (amount > max)
+        throw new Error(`An exit is at most ${show(max)}; send the rest in another exit`);
+    const fee = exitFee(amount, terms);
+    const net = amount - fee;
+    log(`Exit ${show(amount)} from ${network.name}: ${show(net)} arrives on the parent chain (chain ${terms.payoutChainId}) after a ${show(fee)} fee.`);
+    if (options.toSolana !== undefined) {
+        const eth = await chain.parentEth();
+        if (eth < RELAY_GAS_WEI) {
+            throw new Error(`Moving it on to Solana needs about 0.00002 ETH on ${network.bridge?.name ?? "the parent chain"} for gas; the wallet holds ${formatUnits(eth, 18)}. \`fund --from-solana\` brings some.`);
+        }
+    }
+    const solanaQuote = (net) => (options.quote ?? relayQuote)({ user: chain.account, recipient: options.toSolana, originChainId: terms.payoutChainId, destinationChainId: SOLANA_CHAIN_ID, originCurrency: terms.payoutToken, destinationCurrency: SOLANA_USDC, amount: net }, fetchImpl);
+    // Priced before anything leaves BrainChain, so a refused Solana leg never strands the exit halfway.
+    if (options.toSolana !== undefined) {
+        const preview = await solanaQuote(net);
+        checkReturn(preview);
+        log(`Relay quotes ${preview.outFormatted} USDC on Solana for it.`);
+    }
+    if (dry) {
+        log("Dry run, nothing sent.");
+        return;
+    }
+    const tx = await chain.sendToDesk(terms.token, terms.desk, amount);
+    log(`Sent to the desk on ${network.name} (${tx}). Waiting for the payout; the desk picks it up within a round, usually a few minutes.`);
+    const end = Date.now() + (options.waitMs ?? 1_800_000);
+    let last = "";
+    let record;
+    for (;;) {
+        record = await exitRecord(network.service, tx, fetchImpl).catch(() => undefined);
+        if (record?.state === "paid" || record?.state === "returned")
+            break;
+        if (record?.reason && record.reason !== last)
+            log(`Waiting: ${record.reason}.`);
+        last = record?.reason ?? last;
+        if (Date.now() > end) {
+            log(`Still waiting after ${Math.round((options.waitMs ?? 1_800_000) / 60_000)} minutes. The desk pays it or sends it back within a day; follow it at ${network.service}/exits/${tx}.`);
+            return;
+        }
+        await sleep(options.pollMs ?? 10_000);
+    }
+    if (record.state === "returned") {
+        log(`The desk sent it back on ${network.name}: ${record.reason ?? "no reason given"} (${record.returnTx}).`);
+        process.exitCode = 1;
+        return;
+    }
+    log(`Paid on the parent chain: ${show(BigInt(record.net))} (${record.payoutTx}).`);
+    if (options.toSolana === undefined)
+        return;
+    const quote = await solanaQuote(BigInt(record.net));
+    checkReturn(quote);
+    await sendEvmSteps(quote, chain);
+    log(`Moving ${show(BigInt(record.net))} to Solana: ${quote.outFormatted} USDC to ${options.toSolana}.`);
+    const status = await waitForRelay(quote.requestId, 600_000, fetchImpl);
+    if (status === "success")
+        log(`Arrived on Solana. Relay request ${quote.requestId}.`);
+    else {
+        log(`Relay reports "${status}" for request ${quote.requestId}. A refund comes back to the wallet on the parent chain.`);
+        process.exitCode = 1;
+    }
+}
+async function sendEvmSteps(quote, chain) {
+    for (const step of quote.steps) {
+        for (const item of step.items)
+            await chain.sendParent(item.data);
+    }
+}

package/dist/relay.js

@@ -0,0 +1,64 @@
+// Relay (relay.link) moves value between Solana and Robinhood Chain in about a second. The worker uses it to fund
+// itself from Solana and to send its earnings there; every quote is checked against what goes in before anything is
+// signed, so a bad price stops the move instead of costing the worker.
+export const RELAY_API = "https://api.relay.link";
+export const SOLANA_CHAIN_ID = 792703809;
+/** USDC on Solana. */
+export const SOLANA_USDC = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+export const NATIVE = "0x0000000000000000000000000000000000000000";
+/** The most a move may cost, as a share of its dollar value; small moves may cost up to FIXED_LOSS_USD instead. */
+export const MAX_LOSS = 0.03;
+/** Relay's fee is partly fixed (about 0.2 USD), so a small move is allowed to lose up to this much in dollars. */
+export const FIXED_LOSS_USD = 0.5;
+export class RelayError extends Error {
+}
+export async function relayQuote(request, fetchImpl = fetch) {
+    const response = await fetchImpl(`${RELAY_API}/quote`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ ...request, amount: request.amount.toString(), tradeType: "EXACT_INPUT" }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    const body = (await response.json().catch(() => ({})));
+    if (!response.ok || !body.details || !Array.isArray(body.steps)) {
+        throw new RelayError(`Relay has no route for this move right now${body.message ? `: ${body.message}` : ""}`);
+    }
+    const requestId = body.steps.find((s) => s.requestId)?.requestId;
+    if (!requestId)
+        throw new RelayError("Relay's quote carries no request id to follow");
+    return {
+        requestId,
+        steps: body.steps,
+        inUsd: Number(body.details.currencyIn?.amountUsd ?? 0),
+        outUsd: Number(body.details.currencyOut?.amountUsd ?? 0),
+        outAmount: BigInt(body.details.currencyOut?.amount ?? 0),
+        outFormatted: String(body.details.currencyOut?.amountFormatted ?? "0"),
+    };
+}
+/** Refuses a quote that loses more than MAX_LOSS of its dollar value, or FIXED_LOSS_USD on a small move. */
+export function checkReturn(quote) {
+    if (!(quote.inUsd > 0))
+        throw new RelayError("Relay's quote has no dollar value for what goes in, so its price cannot be checked");
+    const loss = quote.inUsd - quote.outUsd;
+    const allowed = Math.max(quote.inUsd * MAX_LOSS, FIXED_LOSS_USD);
+    if (loss > allowed) {
+        throw new RelayError(`Relay would keep ${loss.toFixed(2)} USD of ${quote.inUsd.toFixed(2)}, more than the ${allowed.toFixed(2)} this command accepts (3%, or 0.50 USD on a small move). Nothing was sent; try again later.`);
+    }
+}
+export async function relayStatus(requestId, fetchImpl = fetch) {
+    const response = await fetchImpl(`${RELAY_API}/intents/status/v2?requestId=${requestId}`, { signal: AbortSignal.timeout(20_000) });
+    const body = (await response.json().catch(() => ({})));
+    if (body.status === "success" || body.status === "failure" || body.status === "refund")
+        return body.status;
+    return "pending";
+}
+/** Follows a move until Relay says it landed, failed or was refunded, for at most `ms`. */
+export async function waitForRelay(requestId, ms = 600_000, fetchImpl = fetch, sleep = (t) => new Promise((r) => setTimeout(r, t))) {
+    const end = Date.now() + ms;
+    for (;;) {
+        const status = await relayStatus(requestId, fetchImpl).catch(() => "pending");
+        if (status !== "pending" || Date.now() > end)
+            return status;
+        await sleep(3_000);
+    }
+}

package/dist/solana.js

@@ -0,0 +1,124 @@
+// `fund --from-solana`: an agent that lives on Solana funds its BrainChain worker in one command. Relay turns its USDC
+// on Solana into ETH (and, with --stake, BRAIN) for the worker's wallet on Robinhood Chain in about a second, signed by
+// the agent's Solana key; `bridge` then moves gas and stake on to BrainChain. A little ETH stays on Robinhood Chain for
+// the worker's own transactions there, such as an exit to Solana.
+import { readFileSync } from "node:fs";
+import bs58 from "bs58";
+import { Connection, Keypair, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
+import { formatUnits, parseUnits } from "viem";
+import { checkReturn, NATIVE, relayQuote, SOLANA_CHAIN_ID, SOLANA_USDC, waitForRelay } from "./relay.js";
+export const SOLANA_RPC = "https://api.mainnet-beta.solana.com";
+/** USDC turned into ETH for gas, unless --gas-usdc says otherwise. */
+export const DEFAULT_GAS_USDC = "2";
+/** ETH left on Robinhood Chain when the rest goes to BrainChain: enough for a token deposit and a few transactions there. */
+export const PARENT_ETH_KEEP = 300000000000000n;
+/** The Solana key from BRAINCHAIN_SOLANA_KEY (base58) or BRAINCHAIN_SOLANA_KEY_FILE (a Solana CLI keypair file). */
+export function solanaKeypair(env = process.env) {
+    const file = env.BRAINCHAIN_SOLANA_KEY_FILE?.trim();
+    const raw = file ? readFileSync(file, "utf8").trim() : env.BRAINCHAIN_SOLANA_KEY?.trim();
+    if (!raw)
+        throw new Error("Set BRAINCHAIN_SOLANA_KEY to the Solana wallet's secret key (base58), or BRAINCHAIN_SOLANA_KEY_FILE to its keypair file");
+    try {
+        const bytes = raw.startsWith("[") ? Uint8Array.from(JSON.parse(raw)) : bs58.decode(raw);
+        return Keypair.fromSecretKey(bytes);
+    }
+    catch {
+        throw new Error("The Solana key must be a 64-byte secret key, in base58 or as a keypair file's JSON array");
+    }
+}
+/** How a USDC amount splits between gas and stake. */
+export function split(usdc, gasUsdc, stake) {
+    if (!stake)
+        return { gas: usdc, stake: 0n };
+    if (usdc <= gasUsdc)
+        throw new Error(`With --stake the amount must be more than the ${formatUnits(gasUsdc, 6)} USDC kept for gas`);
+    return { gas: gasUsdc, stake: usdc - gasUsdc };
+}
+/** Sends Relay's Solana deposit: its instructions, compiled against its lookup tables, signed by the agent's key. */
+export async function sendSvmStep(connection, keypair, item) {
+    const instructions = item.instructions.map((i) => new TransactionInstruction({
+        programId: new PublicKey(i.programId),
+        keys: i.keys.map((k) => ({ pubkey: new PublicKey(k.pubkey), isSigner: k.isSigner, isWritable: k.isWritable })),
+        data: Buffer.from(i.data.replace(/^0x/, ""), "hex"),
+    }));
+    const tables = [];
+    for (const address of item.addressLookupTableAddresses) {
+        const table = (await connection.getAddressLookupTable(new PublicKey(address))).value;
+        if (table)
+            tables.push(table);
+    }
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash("confirmed");
+    const message = new TransactionMessage({ payerKey: keypair.publicKey, recentBlockhash: blockhash, instructions }).compileToV0Message(tables);
+    const transaction = new VersionedTransaction(message);
+    transaction.sign([keypair]);
+    const signature = await connection.sendTransaction(transaction, { maxRetries: 3 });
+    const confirmed = await connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, "confirmed");
+    if (confirmed.value.err)
+        throw new Error(`the Solana transaction failed: ${JSON.stringify(confirmed.value.err)}`);
+    return signature;
+}
+export function createSolanaFunding(keypair, parentChainId, rpc = SOLANA_RPC) {
+    const connection = new Connection(rpc, "confirmed");
+    const owner = keypair.publicKey.toBase58();
+    return {
+        owner,
+        async usdcBalance() {
+            const accounts = await connection.getParsedTokenAccountsByOwner(keypair.publicKey, { mint: new PublicKey(SOLANA_USDC) });
+            return accounts.value.reduce((sum, a) => sum + BigInt(a.account.data.parsed.info.tokenAmount.amount), 0n);
+        },
+        async solBalance() {
+            return BigInt(await connection.getBalance(keypair.publicKey));
+        },
+        async preview(currency, amount, recipient) {
+            const quote = await relayQuote({ user: owner, recipient, originChainId: SOLANA_CHAIN_ID, destinationChainId: parentChainId, originCurrency: SOLANA_USDC, destinationCurrency: currency, amount });
+            checkReturn(quote);
+            return quote;
+        },
+        async move(currency, amount, recipient) {
+            const quote = await this.preview(currency, amount, recipient);
+            let signature = "";
+            for (const step of quote.steps)
+                for (const item of step.items)
+                    signature = await sendSvmStep(connection, keypair, item.data);
+            const status = await waitForRelay(quote.requestId);
+            if (status !== "success")
+                throw new Error(`Relay reports "${status}" for request ${quote.requestId}; a refund comes back to the Solana wallet`);
+            return { quote, signature };
+        },
+    };
+}
+/** The least SOL the wallet needs to pay Solana's fees for the deposits. */
+export const MIN_LAMPORTS = 2000000n;
+export async function fundFromSolana(options) {
+    const { funding, log } = options;
+    const usdc = parseUnits(options.usdc, 6);
+    const gasUsdc = parseUnits(options.gasUsdc ?? DEFAULT_GAS_USDC, 6);
+    const parts = split(usdc, gasUsdc, options.stake);
+    if (options.stake && !options.stakeToken)
+        throw new Error("This network's stake token is not on the parent chain");
+    const [held, lamports] = await Promise.all([funding.usdcBalance(), funding.solBalance()]);
+    if (held < usdc)
+        throw new Error(`The Solana wallet ${funding.owner} holds ${formatUnits(held, 6)} USDC, less than ${options.usdc}`);
+    if (lamports < MIN_LAMPORTS)
+        throw new Error(`The Solana wallet ${funding.owner} needs about 0.002 SOL for Solana's fees; it holds ${formatUnits(lamports, 9)}`);
+    log(`From ${funding.owner} on Solana: ${formatUnits(parts.gas, 6)} USDC to ETH for gas${parts.stake ? ` and ${formatUnits(parts.stake, 6)} USDC to the stake token` : ""}, for ${options.worker}.`);
+    // Both legs are priced before either moves, so a refused stake leg never leaves the gas leg spent alone.
+    const gasQuote = await funding.preview(NATIVE, parts.gas, options.worker);
+    const stakeQuote = parts.stake ? await funding.preview(options.stakeToken, parts.stake, options.worker) : undefined;
+    log(`Relay quotes ${gasQuote.outFormatted} ETH${stakeQuote ? ` and ${stakeQuote.outFormatted} of the stake token` : ""}.`);
+    if (options.dry) {
+        log("Dry run, nothing sent.");
+        return;
+    }
+    const gas = await funding.move(NATIVE, parts.gas, options.worker);
+    log(`ETH arrived on the parent chain: ${gas.quote.outFormatted} ETH (Solana ${gas.signature}).`);
+    if (parts.stake) {
+        const stake = await funding.move(options.stakeToken, parts.stake, options.worker);
+        log(`Stake token arrived on the parent chain: ${stake.quote.outFormatted} (Solana ${stake.signature}).`);
+    }
+    // The stake goes first: its deposit pays for its arrival in ETH on the parent chain, which the ETH bridge would take.
+    if (parts.stake)
+        await options.bridgeOn("stake");
+    await options.bridgeOn("eth");
+    log("Done. `brainchain-worker status` shows the balances on BrainChain once the deposits arrive, in about a minute.");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brainchain-worker",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "description": "Earn on BrainChain and propose changes to it: stake, apply, do the tasks Jev hires your agent for, and bond BRAIN to put a change to Jev.",
   "license": "MIT",
   "author": "BrainChain <hello@usebrainchain.com>",
@@ -28,7 +28,9 @@
     "prepack": "npm run build"
   },
   "dependencies": {
+    "@solana/web3.js": "^1.99.0",
     "brainchain-verify": "^0.4.0",
+    "bs58": "^6.0.0",
     "viem": "^2.57.12"
   },
   "devDependencies": {