import {
  configure,
  quoteDeposit,
  prepareDepositTx,
  submitDeposit,
  getStatus,
  isTerminal,
} from "@moveindustries/near-intents-sdk";

// configure() is optional — omit it entirely to run token-free (see Authentication).
configure({ jwt: process.env.ONE_CLICK_JWT });

// 1. Quote the route. Amounts are in the origin asset's smallest units.
const res = await quoteDeposit({
  originChain: "ethereum",     // "ethereum" | "polygon" | "tron"
  originAsset: "usdc",         // "usdc" | "usdt"  (Tron is USDT-only)
  destinationAsset: "usdcx",   // "usdcx" | "move"
  amount: "1000000",           // 1.0 USDC (6 decimals)
  recipient: "0xYourMovementAddress",
  refundTo: "0xYourEthereumAddress",
  minAmountOut: "995000",      // required floor, destination asset's smallest units; "0" opts out
});

const { depositAddress, amountOut, deadline } = res.quote;
console.log(`Send to ${depositAddress}, you'll receive ~${amountOut} before ${deadline}`);

// 2. Build the unsigned deposit transfer. Your wallet signs and broadcasts it.
const depositTx = prepareDepositTx("ethereum", "usdc", res);

// ...sign & broadcast `depositTx` with your wallet (see per-chain examples below)...
const txHash = "0xYourDepositTxHash";

// 3. (Optional) Hand 1Click the tx hash to speed up deposit detection.
await submitDeposit(depositAddress!, txHash);

// 4. Poll status until it settles.
let status = (await getStatus(depositAddress!)).status;
while (!isTerminal(status)) {
  await new Promise((r) => setTimeout(r, 5000));
  status = (await getStatus(depositAddress!)).status;
}
console.log("Final:", status); // "SUCCESS" | "REFUNDED" | "FAILED"

configure({ jwt: process.env.ONE_CLICK_JWT });

// Client code — no secret here. Requests go to your proxy, which adds the JWT.
configure({ baseUrl: "/api/1click" });

// EVM (Ethereum, Polygon)
{ family: "evm", to: string, value: "0x0", data: string }

// Tron
{ family: "tron", contractAddress: string, function: "transfer(address,uint256)", parameter: [depositAddress, amountIn] }

import { getStatus, isTerminal } from "@moveindustries/near-intents-sdk";

async function waitForSettlement(depositAddress: string) {
  for (;;) {
    const { status } = await getStatus(depositAddress);
    if (isTerminal(status)) return status; // SUCCESS | REFUNDED | FAILED
    await new Promise((r) => setTimeout(r, 5000));
  }
}

import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { mainnet } from "viem/chains"; // Polygon: import { polygon }
import { configure, quoteDeposit, prepareDepositTx, submitDeposit } from "@moveindustries/near-intents-sdk";

// Server-side, JWT stays private:
configure({ jwt: process.env.ONE_CLICK_JWT }); // optional
// In the browser instead: configure({ baseUrl: "/api/1click" }) — the proxy holds the JWT.

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const wallet = createWalletClient({ account, chain: mainnet, transport: http() });

const res = await quoteDeposit({
  originChain: "ethereum",   // or "polygon"
  originAsset: "usdc",
  destinationAsset: "usdcx", // for "move", also raise slippageTolerance below
  amount: "1000000",         // 1.0 USDC
  recipient: "0xYourMovementAddress",
  refundTo: account.address,
  minAmountOut: "995000",    // required floor, destination asset's smallest units; "0" opts out
  // slippageTolerance: 300, // MOVE only: 3% — MOVE is volatile; the 1% default often refunds
});
const { depositAddress } = res.quote;

// prepareDepositTx returns { family: "evm", to, value: "0x0", data } — send it as-is.
const tx = prepareDepositTx("ethereum", "usdc", res); // match originChain above
const txHash = await wallet.sendTransaction({
  account,
  chain: mainnet,
  to: tx.to as `0x${string}`,
  value: 0n,
  data: tx.data as `0x${string}`,
});

await submitDeposit(depositAddress!, txHash); // optional speed-up
console.log("Settled:", await waitForSettlement(depositAddress!));

import { configure, quoteDeposit, prepareDepositTx, submitDeposit } from "@moveindustries/near-intents-sdk";

configure({ baseUrl: "/api/1click" });

async function bridgeTronToUsdcx(recipient: string, refundTo: string) {
  const tronWeb = (window as any).tronWeb;
  if (!tronWeb?.defaultAddress?.base58) throw new Error("Connect TronLink");

  const res = await quoteDeposit({
    originChain: "tron",
    originAsset: "usdt",
    destinationAsset: "usdcx",
    amount: "1000000", // 1.0 USDT
    recipient,
    refundTo, // your Tron address, for refunds
    minAmountOut: "995000", // required floor, destination asset's smallest units; "0" opts out
  });
  const { depositAddress } = res.quote;

  // prepareDepositTx returns { family: "tron", contractAddress, function, parameter: [to, amount] }
  const tx = prepareDepositTx("tron", "usdt", res);
  const contract = await tronWeb.contract().at(tx.contractAddress);
  const txId: string = await contract.transfer(tx.parameter[0], tx.parameter[1]).send();

  await submitDeposit(depositAddress!, txId);
  return waitForSettlement(depositAddress!);
}

import { TronWeb } from "tronweb";
import { useWallet } from "@tronweb3/tronwallet-adapter-react-hooks";
import { configure, quoteDeposit, prepareDepositTx, submitDeposit } from "@moveindustries/near-intents-sdk";

configure({ baseUrl: "/api/1click" });

// A read-only client just for building + broadcasting; the adapter does the signing.
const tronWeb = new TronWeb({ fullHost: "https://api.trongrid.io" });

function BridgeButton({ recipient }: { recipient: string }) {
  const { address, signTransaction, connected } = useWallet();

  async function bridge() {
    if (!connected || !address) throw new Error("Connect a Tron wallet");

    const res = await quoteDeposit({
      originChain: "tron",
      originAsset: "usdt",
      destinationAsset: "usdcx",
      amount: "1000000", // 1.0 USDT
      recipient,
      refundTo: address,
      minAmountOut: "995000", // required floor, destination asset's smallest units; "0" opts out
    });
    const { depositAddress } = res.quote;

    const tx = prepareDepositTx("tron", "usdt", res);

    // Build the TRC-20 transfer from prepareDepositTx's contract + params.
    const { transaction } = await tronWeb.transactionBuilder.triggerSmartContract(
      tx.contractAddress,
      tx.function, // "transfer(address,uint256)"
      {},
      [
        { type: "address", value: tx.parameter[0] }, // deposit address
        { type: "uint256", value: tx.parameter[1] }, // amountIn
      ],
      address,
    );

    const signed = await signTransaction(transaction);
    const receipt = await tronWeb.trx.sendRawTransaction(signed);
    const txId: string = receipt.txid;

    await submitDeposit(depositAddress!, txId);
    return waitForSettlement(depositAddress!);
  }

  return <button onClick={bridge}>Bridge USDT → USDCx</button>;
}

import { listTokens } from "@moveindustries/near-intents-sdk";

const tokens = await listTokens();
// each token carries: assetId, symbol, decimals, chain, contractAddress, price,
// and its route keys — originChain, originAsset (sources) or destinationAsset (Movement)

const preview = await quoteDeposit({
  originChain: "ethereum",
  originAsset: "usdc",
  destinationAsset: "usdcx",
  amount: "1000000",
  recipient: "0xYourMovementAddress",
  refundTo: "0xYourEthereumAddress",
  minAmountOut: "0", // required; "0" opts out — fine for a price-only preview
  dry: true,
});
console.log("You'd receive ~", preview.quote.amountOutFormatted ?? preview.quote.amountOut);