NEAR

import bs58 from "bs58";

function deriveNearAddress(solanaAddress: string): string {
  return bytesToHex(bs58.decode(solanaAddress)); // 64-char hex string
}

async function signNearMessage(message: string): Promise<string> {
  const wallet = dynamicClient.wallets.userWallets.find(w => w.chain === "SOL")!;
  const messageBytes = new TextEncoder().encode(message);
  const { signedMessage } = await dynamicClient.wallets.signMessage({
    wallet,
    message: bytesToHex(messageBytes),
  });
  return signedMessage;
}

import { sha256 } from "@noble/hashes/sha2";
import bs58 from "bs58";

async function sendNearTransfer(
  recipient: string,
  amountNear: number,
  nearAddress: string,
): Promise<string> {
  const wallet = dynamicClient.wallets.userWallets.find(w => w.chain === "SOL")!;
  const pubkey = bs58.decode(wallet.address);

  const [wholePart, fracPart = ""] = amountNear.toString().split(".");
  const paddedFrac = fracPart.padEnd(24, "0").slice(0, 24);
  const amountYocto = BigInt(wholePart + paddedFrac);

  const [accessKeyResult, blockResult] = await Promise.all([
    nearRpc("query", {
      request_type: "view_access_key",
      finality: "final",
      account_id: nearAddress,
      public_key: `ed25519:${bs58.encode(pubkey)}`,
    }),
    nearRpc("block", { finality: "final" }),
  ]);

  const nonce = BigInt(accessKeyResult.nonce) + BigInt(1);
  const blockHash = bs58.decode(blockResult.header.hash);

  const txBytes = concatBytes(
    borshString(nearAddress),
    borshU8(0),   // PublicKey variant: ed25519
    pubkey,       // 32-byte pubkey
    borshU64(nonce),
    borshString(recipient),
    blockHash,    // 32-byte block hash
    borshU32(1),  // number of actions
    borshU8(3),   // Transfer action variant
    borshU128(amountYocto),
  );

  const txHash = sha256(txBytes);
  const { signedMessage } = await dynamicClient.wallets.signMessage({
    wallet,
    message: bytesToHex(txHash),
  });
  const sigBytes = decodeSig(signedMessage);

  const signedTxBytes = concatBytes(txBytes, borshU8(0), sigBytes);
  const signedTxBase64 = btoa(String.fromCharCode(...signedTxBytes));
  const result = await nearRpc("broadcast_tx_commit", [signedTxBase64]);

  return result.transaction.hash;
}

import { ed25519 } from "@noble/curves/ed25519";
import bs58 from "bs58";

function verifyNearSignature(
  message: string,
  signature: string,
  solanaAddress: string,
): boolean {
  const pubkey = bs58.decode(solanaAddress);
  const messageBytes = new TextEncoder().encode(message);
  const sigBytes = decodeSig(signature);
  return ed25519.verify(sigBytes, messageBytes, pubkey);
}

async function getNearBalance(accountId: string): Promise<string> {
  const res = await fetch("https://rpc.testnet.near.org", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      jsonrpc: "2.0",
      id: "1",
      method: "query",
      params: { request_type: "view_account", finality: "final", account_id: accountId },
    }),
  });
  const data = await res.json();
  if (data.error) return "0";
  const yocto = BigInt(data.result.amount);
  const divisor = BigInt(10) ** BigInt(24);
  const whole = yocto / divisor;
  const frac = (yocto % divisor).toString().padStart(24, "0").replace(/0+$/, "");
  return frac.length === 0 ? whole.toString() : `${whole}.${frac}`;
}