import { actions, queryAccessKey, queryProtocolVersion, sendTx } from "@fastnear/api";
import { privateKeyFromRandom, signerFromPrivateKey } from "@fastnear/utils";

export async function addGasKey({ accountId, ownerSigner, numNonces = 4 }) {
  const protocolVersion = await queryProtocolVersion({ network: "testnet" });
  if (protocolVersion < 85) {
    throw new Error(`testnet protocol ${protocolVersion} does not support gas keys`);
  }

  // A gas key is an ordinary ed25519 key pair; only its permission differs.
  const gasKeyPrivateKey = privateKeyFromRandom("ed25519");
  const gasSigner = signerFromPrivateKey(gasKeyPrivateKey);

  await sendTx({
    signerId: accountId,
    signer: ownerSigner,
    receiverId: accountId,
    // numNonces = independent transaction lanes (1..1024); the AddKey fee grows with it.
    actions: [actions.addFullAccessGasKey({ publicKey: gasSigner.publicKey, numNonces })],
    waitUntil: "FINAL",
    network: "testnet",
  });

  const view = await queryAccessKey({
    accountId,
    publicKey: gasSigner.publicKey,
    blockId: "final",
    network: "testnet",
  });
  // view.result.permission -> { GasKeyFullAccess: { balance: "0", num_nonces: 4 } }
  return { gasKeyPrivateKey, publicKey: gasSigner.publicKey, permission: view.result.permission };
}

import { actions, gasKeyInfoFromPermission, queryAccessKey, sendTx } from "@fastnear/api";

export async function fundGasKey({ funderId, funderSigner, accountId, publicKey, amount = "0.05 NEAR" }) {
  await sendTx({
    signerId: funderId,
    signer: funderSigner,
    receiverId: accountId,
    actions: [actions.transferToGasKey({ publicKey, deposit: amount })],
    waitUntil: "FINAL",
    network: "testnet",
  });

  const view = await queryAccessKey({ accountId, publicKey, blockId: "final", network: "testnet" });
  const info = gasKeyInfoFromPermission(view.result.permission);
  if (!info) throw new Error(`${publicKey} is not a gas key on ${accountId}`);
  return info.balance; // yoctoNEAR decimal string
}

import { actions, queryGasKeyNonces, sendTx } from "@fastnear/api";

export async function sendWithGasKey({ accountId, gasSigner, receiverId, nonceIndex = 0 }) {
  const result = await sendTx({
    signerId: accountId,
    signer: gasSigner,
    receiverId,
    actions: [actions.functionCall({ methodName: "ping", args: {}, gas: "30 Tgas", deposit: "0" })],
    nonceIndex,
    waitUntil: "FINAL",
    network: "testnet",
  });

  const nonces = await queryGasKeyNonces({
    accountId,
    publicKey: gasSigner.publicKey,
    blockId: "final",
    network: "testnet",
  });
  return { txHash: result.transaction?.hash ?? null, nonces: nonces.result.nonces };
}

// Lanes are independent nonce sequences, so these do not serialize behind each other.
export const sendOnTwoLanes = (params) =>
  Promise.all([0, 1].map((nonceIndex) => sendWithGasKey({ ...params, nonceIndex })));

import {
  gasKeyInfoFromPermission,
  queryAccessKey,
  queryAccessKeyList,
  queryGasKeyNonces,
} from "@fastnear/api";

export async function inspectGasKey({ accountId, publicKey }) {
  const [direct, lanes, list] = await Promise.all([
    queryAccessKey({ accountId, publicKey, blockId: "final", network: "testnet" }),
    queryGasKeyNonces({ accountId, publicKey, blockId: "final", network: "testnet" }),
    queryAccessKeyList({ accountId, blockId: "final", network: "testnet" }),
  ]);
  const info = gasKeyInfoFromPermission(direct.result.permission);
  if (!info) throw new Error(`${publicKey} is not a gas key on ${accountId}`);
  return {
    balance: info.balance,
    numNonces: info.num_nonces,
    nonces: lanes.result.nonces,
    // Set only for GasKeyFunctionCall keys.
    receiverId: info.functionCall?.receiver_id ?? null,
    listed: list.result.keys.some((key) => key.public_key === publicKey),
  };
}

import { actions, gasKeyInfoFromPermission, queryAccessKey, sendTx } from "@fastnear/api";

export async function withdrawAndDeleteGasKey({ accountId, ownerSigner, publicKey }) {
  const view = await queryAccessKey({ accountId, publicKey, blockId: "final", network: "testnet" });
  const info = gasKeyInfoFromPermission(view.result.permission);
  if (!info) throw new Error(`${publicKey} is not a gas key on ${accountId}`);

  // DeleteKey fails above 1 NEAR and burns anything below it, so withdraw first.
  // WithdrawFromGasKey must be signed by the owning account itself.
  const drain = BigInt(info.balance) > 0n
    ? [actions.withdrawFromGasKey({ publicKey, amount: info.balance })]
    : [];
  await sendTx({
    signerId: accountId,
    signer: ownerSigner,
    receiverId: accountId,
    actions: [...drain, actions.deleteKey({ publicKey })],
    waitUntil: "FINAL",
    network: "testnet",
  });

  const after = await queryAccessKey({ accountId, publicKey, blockId: "final", network: "testnet" });
  if (!/UnknownAccessKey|does not exist/i.test(after.result.error ?? "")) {
    throw new Error("gas key still present");
  }
}