import { createWalletClient, http, publicActions, encodeFunctionData, erc20Abi } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains";
const API = "https://app.ravn.exchange/api/v1";
const SANDBOX = process.env.SANDBOX === "1"; // a test run: nothing is signed or sent
const destinationAddress = process.env.SOL_DESTINATION; // your user's Solana wallet
if (!destinationAddress) throw new Error("Set SOL_DESTINATION: the SOL is paid there");
const wallet = createWalletClient({
account: privateKeyToAccount(process.env.PRIVATE_KEY),
chain: mainnet,
transport: http(),
}).extend(publicActions);
async function ravn(path, body) {
const res = await fetch(`${API}${path}`, {
method: "POST",
headers: {
"content-type": "application/json",
// Your fee only applies to calls made with your key.
...(process.env.RAVN_API_KEY ? { "x-api-key": process.env.RAVN_API_KEY } : {}),
},
body: JSON.stringify(body),
});
const { data, error } = await res.json();
if (error) throw new Error(`${error.code}: ${error.message}`);
return data;
}
// Send one of RAVN's EVM transactions and wait until it is mined. RAVN's `value` is a decimal
// string: viem needs a bigint (and lower-case addresses pass viem's checksum check). Returns the
// hash of the transaction that ran, and throws unless it succeeded. A sped-up copy (same
// transaction, higher gas) counts; a cancelled one doesn't.
async function send({ to, data, value }) {
const hash = await wallet.sendTransaction({ to: to.toLowerCase(), data, value: BigInt(value ?? "0") });
let replaced;
const receipt = await wallet.waitForTransactionReceipt({ hash, onReplaced: (r) => (replaced = r) });
const ran = receipt.transactionHash === hash || replaced?.reason === "repriced";
if (receipt.status !== "success" || !ran) throw new Error(`${hash} didn't succeed`);
return receipt.transactionHash;
}
// RAVN leaves `approval` out when it reads enough allowance on-chain, but keeps it when that
// read fails: skip it when the allowance already covers it.
async function approve(approval) {
const { to, spender, amount } = approval;
const allowance = spender
? await wallet.readContract({ address: to.toLowerCase(), abi: erc20Abi, functionName: "allowance", args: [wallet.account.address, spender.toLowerCase()] })
: 0n;
if (allowance >= BigInt(amount)) return;
if (approval.reset) await send(approval.reset); // approve(spender, 0) first: Ethereum USDT with a partial allowance
await send(approval); // MINED before the swap, or it reverts on transferFrom
}
// RAVN's fee beside the swap, sent only once the swap or deposit has succeeded. A failed fee
// never stops the script: the swap is out and still needs tracking.
async function payFee(fee) {
if (!fee?.transaction) return undefined; // Bitcoin or Solana: the fee rides in the deposit itself
try {
return await send(fee.transaction);
} catch (e) {
console.log(`fee not paid, so nothing is owed on this swap: ${e.message}`);
}
}
const quote = await ravn("/quote", {
inputChainId: 1,
outputChainId: -2,
inputToken: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
outputToken: "So11111111111111111111111111111111111111112",
inputAmount: "1000000000000000000",
userAddress: wallet.account.address,
destinationAddress,
...(SANDBOX ? { sandbox: true } : {}),
});
const res = await ravn("/execute", { quoteToken: quote.quoteToken });
let ref; // what /status tracks this swap by
let txHash; // the transaction that paid your fee (or a two-hop route's hop 1), for /status
// A sandbox execution is a test: never send it (its transaction can be real and signable).
// /status answers it at once, whatever the ref.
if (SANDBOX || res.sandbox) ref = res.statusRef ?? "sandbox";
else switch (res.executionType) {
case "TRANSACTION": {
// This wallet handles EVM transactions. A Solana one (`transaction.serialized`), or one
// carrying `submit`, is signed by a Solana wallet: see Execution types.
if (res.approval) await approve(res.approval);
const hash = await send(res.transaction);
// Eco Routes, Layerswap, Mayan routes paying no referrer; else, on a two-hop route
// (`statusRef` present), hop 1's own hash proves the fee.
txHash = (await payFee(res.fee)) ?? (res.statusRef ? hash : undefined);
ref = res.statusRef ?? hash;
break;
}
case "SIGNATURE": {
// Gasless still needs an on-chain allowance, or the order never fills, silently.
if (res.approval) await approve(res.approval);
// 0x Gasless: `approvalData` is a second signature, approving the token gaslessly.
const approvalSignature = res.approvalData ? await wallet.signTypedData(res.approvalData) : undefined;
const signature = await wallet.signTypedData(res.typedData);
({ statusRef: ref } = await ravn("/submit-signature", {
quoteToken: res.quoteToken, // execute's token, not /quote's
signature,
approvalSignature,
}));
break;
}
case "DEPOSIT": {
// The deposit names no token: send the quote's INPUT token, exactly deposit.amount.
const { address, amount } = res.deposit;
const input = quote.input.token;
await send(
input.isNative
? { to: address, value: amount }
: {
to: input.address,
data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: [address.toLowerCase(), BigInt(amount)] }),
}
);
txHash = await payFee(res.fee); // Rift, private swaps
ref = res.statusRef;
break;
}
}
