@omni-bridge/near

import {
  // Factory
  createNearBuilder,
  type NearBuilder,
  type NearBuilderConfig,

  // Shims
  toNearKitTransaction,
  toNearApiJsActions,
  sendWithNearApiJs,

  // Storage utilities
  calculateStorageAccountId,
  type TransferMessageForStorage,

  // MPC Signature
  MPCSignature,
  type MPCSignatureRaw,

  // Proof serialization schemas
  EvmVerifyProofArgsSchema,
  WormholeVerifyProofArgsSchema,
  EvmProofSchema,
  FinTransferArgsSchema,
  DeployTokenArgsSchema,
  BindTokenArgsSchema,
  StorageDepositActionSchema,
  ChainKindSchema,
  ProofKindSchema,

  // Enums and constants
  ProofKind,
  GAS,
  DEPOSIT,

  // Types
  type EvmVerifyProofArgs,
  type WormholeVerifyProofArgs,
  type NearEvmProof,
  type FinalizationParams,
  type FastFinTransferParams,
  type TransferId,
  type TransferFee,
  type StorageDepositAction,
  type InitTransferEvent,
  type SignTransferEvent,
  type LogMetadataEvent,

  // UTXO types
  type UTXO,
  type UtxoBridgeFee,
  type UtxoConnectorConfig,
  type UtxoDepositFinalizationParams,
  type UtxoDepositMsg,
  type UtxoPostAction,
  type UtxoWithdrawalInitParams,
  type UtxoWithdrawalOutput,
  type UtxoWithdrawalVerifyParams,
} from "@omni-bridge/near"

function createNearBuilder(config: NearBuilderConfig): NearBuilder

import { createNearBuilder } from "@omni-bridge/near"

const nearBuilder = createNearBuilder({ network: "mainnet" })

buildTransfer(validated: ValidatedTransfer, signerId: string): NearUnsignedTransaction

import { createBridge } from "@omni-bridge/core"
import { createNearBuilder, toNearKitTransaction } from "@omni-bridge/near"
import { Near } from "near-kit"

const bridge = createBridge({ network: "mainnet" })
const nearBuilder = createNearBuilder({ network: "mainnet" })
const near = new Near({ network: "mainnet", privateKey: "ed25519:..." })

const validated = await bridge.validateTransfer({
  token: "near:wrap.near",
  amount: 1000000000000000000000000n,
  fee: 0n,
  nativeFee: 0n,
  sender: "near:alice.near",
  recipient: "eth:0x1234567890123456789012345678901234567890",
})

const unsigned = nearBuilder.buildTransfer(validated, "alice.near")
const result = await toNearKitTransaction(near, unsigned).send()

buildStorageDeposit(signerId: string, amount: bigint): NearUnsignedTransaction

const deposit = await nearBuilder.getRequiredStorageDeposit("alice.near")

if (deposit > 0n) {
  const tx = nearBuilder.buildStorageDeposit("alice.near", deposit)
  await toNearKitTransaction(near, tx).send()
}

getRequiredStorageDeposit(accountId: string): Promise<bigint>

const deposit = await nearBuilder.getRequiredStorageDeposit("alice.near")
console.log(`Need to deposit ${deposit} yoctoNEAR`)

isTokenStorageRegistered(tokenId: string): Promise<boolean>

const isRegistered = await nearBuilder.isTokenStorageRegistered("wrap.near")

if (!isRegistered) {
  const tx = await nearBuilder.buildTokenStorageDeposit("wrap.near", "alice.near")
  await toNearKitTransaction(near, tx).send()
}

buildTokenStorageDeposit(tokenId: string, signerId: string): Promise<NearUnsignedTransaction>

const tx = await nearBuilder.buildTokenStorageDeposit("wrap.near", "alice.near")
await toNearKitTransaction(near, tx).send()

buildFinalization(params: FinalizationParams): NearUnsignedTransaction

import { ChainKind } from "@omni-bridge/core"

const tx = nearBuilder.buildFinalization({
  sourceChain: ChainKind.Eth,
  storageDepositActions: [],
  vaa: "AQAAAAMNALfP...", // Wormhole VAA
  signerId: "relayer.near",
})

buildLogMetadata(token: string, signerId: string): NearUnsignedTransaction

const tx = nearBuilder.buildLogMetadata("wrap.near", "alice.near")
await toNearKitTransaction(near, tx).send()

buildDeployToken(
  destinationChain: ChainKind,
  proverArgs: Uint8Array,
  signerId: string,
  deposit: bigint
): NearUnsignedTransaction

import { ChainKind } from "@omni-bridge/core"

const proverArgs = nearBuilder.serializeWormholeProofArgs({
  proof_kind: ProofKind.LogMetadata,
  vaa: vaaString,
})

const tx = nearBuilder.buildDeployToken(
  ChainKind.Eth,
  proverArgs,
  "alice.near",
  1000000000000000000000000n // 1 NEAR
)

buildBindToken(
  sourceChain: ChainKind,
  proverArgs: Uint8Array,
  signerId: string,
  deposit: bigint
): NearUnsignedTransaction

import { ChainKind } from "@omni-bridge/core"

const tx = nearBuilder.buildBindToken(
  ChainKind.Eth,
  proverArgs,
  "alice.near",
  1000000000000000000000000n
)

buildSignTransfer(
  transferId: TransferId,
  feeRecipient: string,
  fee: { fee: string; native_fee: string },
  signerId: string
): NearUnsignedTransaction

import { ChainKind } from "@omni-bridge/core"

const tx = nearBuilder.buildSignTransfer(
  { origin_chain: ChainKind.Eth, origin_nonce: 123n },
  "relayer.near",
  { fee: "1000000", native_fee: "0" },
  "relayer.near"
)

buildFastFinTransfer(params: FastFinTransferParams, signerId: string): NearUnsignedTransaction

import { ChainKind } from "@omni-bridge/core"

const tx = nearBuilder.buildFastFinTransfer({
  tokenId: "wrap.near",
  amount: "1000000000000000000000000",
  amountToSend: "999000000000000000000000",
  transferId: { origin_chain: ChainKind.Eth, origin_nonce: 123n },
  recipient: "near:bob.near",
  fee: { fee: "1000000", native_fee: "0" },
  storageDepositAmount: "1250000000000000000000",
  relayer: "relayer.near",
}, "relayer.near")

serializeEvmProofArgs(args: EvmVerifyProofArgs): Uint8Array

const serialized = nearBuilder.serializeEvmProofArgs({
  proof_kind: ProofKind.InitTransfer,
  proof: {
    log_index: 0n,
    log_entry_data: new Uint8Array([...]),
    receipt_index: 0n,
    receipt_data: new Uint8Array([...]),
    header_data: new Uint8Array([...]),
    proof: [new Uint8Array([...])],
  },
})

serializeWormholeProofArgs(args: WormholeVerifyProofArgs): Uint8Array

const serialized = nearBuilder.serializeWormholeProofArgs({
  proof_kind: ProofKind.InitTransfer,
  vaa: "AQAAAAMNALfP...",
})

buildUtxoDepositFinalization(params: UtxoDepositFinalizationParams): NearUnsignedTransaction

buildUtxoWithdrawalInit(params: UtxoWithdrawalInitParams): NearUnsignedTransaction

buildUtxoWithdrawalVerify(params: UtxoWithdrawalVerifyParams): NearUnsignedTransaction

getUtxoConnectorAddress(chain: "btc" | "zcash"): string

getUtxoTokenAddress(chain: "btc" | "zcash"): string

getUtxoConnectorConfig(chain: "btc" | "zcash"): Promise<UtxoConnectorConfig>

getUtxoAvailableOutputs(chain: "btc" | "zcash"): Promise<UTXO[]>

getUtxoTokenBalance(chain: "btc" | "zcash", accountId: string): Promise<bigint>

calculateUtxoWithdrawalFee(chain: "btc" | "zcash", amount: bigint): Promise<bigint>

function toNearKitTransaction(near: Near, unsigned: NearUnsignedTransaction): TransactionBuilder

import { Near } from "near-kit"
import { createNearBuilder, toNearKitTransaction } from "@omni-bridge/near"

const near = new Near({
  network: "mainnet",
  privateKey: "ed25519:...",
})
const nearBuilder = createNearBuilder({ network: "mainnet" })

const unsigned = nearBuilder.buildTransfer(validated, "alice.near")
const result = await toNearKitTransaction(near, unsigned).send()

function toNearApiJsActions(unsigned: NearUnsignedTransaction): Action[]

import { Account } from "@near-js/accounts"
import { JsonRpcProvider } from "@near-js/providers"
import { InMemoryKeyStore } from "@near-js/keystores"
import { KeyPair } from "@near-js/crypto"
import { InMemorySigner } from "@near-js/signers"
import { toNearApiJsActions } from "@omni-bridge/near"

const keyStore = new InMemoryKeyStore()
await keyStore.setKey("mainnet", "alice.near", KeyPair.fromString("ed25519:..."))
const provider = new JsonRpcProvider({ url: "https://rpc.mainnet.near.org" })
const signer = new InMemorySigner(keyStore)
const account = new Account({ accountId: "alice.near", provider, signer })

const actions = toNearApiJsActions(unsigned)
const result = await account.signAndSendTransaction({
  receiverId: unsigned.receiverId,
  actions,
})

function sendWithNearApiJs(
  account: Account,
  unsigned: NearUnsignedTransaction
): Promise<FinalExecutionOutcome>

import { Account } from "@near-js/accounts"
import { sendWithNearApiJs } from "@omni-bridge/near"

// ... setup account as shown above

const unsigned = nearBuilder.buildTransfer(validated, "alice.near")
const result = await sendWithNearApiJs(account, unsigned)
console.log("Transaction hash:", result.transaction.hash)

constructor(big_r: AffinePoint, s: Scalar, recovery_id: number)

toBytes(forEvm: boolean = false): Uint8Array

static fromRaw(raw: MPCSignatureRaw): MPCSignature

import { MPCSignature } from "@omni-bridge/near"

// From contract logs
const raw = {
  big_r: { affine_point: "02abc..." },
  s: { scalar: "def..." },
  recovery_id: 0,
}

const signature = MPCSignature.fromRaw(raw)

// For Solana
const solanaBytes = signature.toBytes(false)

// For EVM (adds 27 to recovery_id)
const evmBytes = signature.toBytes(true)

function calculateStorageAccountId(transferMessage: TransferMessageForStorage): string

import { calculateStorageAccountId } from "@omni-bridge/near"

const storageAccountId = calculateStorageAccountId({
  token: "near:wrap.near",
  amount: 1000000000000000000000000n,
  recipient: "eth:0x1234567890123456789012345678901234567890",
  fee: { fee: 0n, native_fee: 0n },
  sender: "near:alice.near",
  msg: "",
})

interface NearUnsignedTransaction {
  type: "near"
  signerId: string
  receiverId: string
  actions: NearAction[]
}

interface NearAction {
  type: "FunctionCall"
  methodName: string
  args: Uint8Array
  gas: bigint
  deposit: bigint
}

interface TransferId {
  origin_chain: ChainKind | number | string
  origin_nonce: bigint | string
}

interface TransferFee {
  fee: string
  native_fee: string
}

interface StorageDepositAction {
  token_id: string
  account_id: string
  storage_deposit_amount?: bigint
}

interface UtxoPostAction {
  receiver_id: string
  amount: bigint
  memo?: string
  msg: string
  gas?: bigint
}

interface UtxoBridgeFee {
  fee_min: string
  fee_rate: number
  protocol_fee_rate: number
}

interface UTXO {
  txid: string
  vout: number
  balance: bigint
  path?: string
  tx_bytes?: number[]
}

enum ProofKind {
  InitTransfer = 0,
  FinTransfer = 1,
  DeployToken = 2,
  LogMetadata = 3,
}

const GAS = {
  LOG_METADATA: 300_000_000_000_000n,      // 300 Tgas
  DEPLOY_TOKEN: 120_000_000_000_000n,      // 120 Tgas
  BIND_TOKEN: 300_000_000_000_000n,        // 300 Tgas
  INIT_TRANSFER: 300_000_000_000_000n,     // 300 Tgas
  FIN_TRANSFER: 300_000_000_000_000n,      // 300 Tgas
  SIGN_TRANSFER: 300_000_000_000_000n,     // 300 Tgas
  STORAGE_DEPOSIT: 10_000_000_000_000n,    // 10 Tgas
  FAST_FIN_TRANSFER: 300_000_000_000_000n, // 300 Tgas
  UTXO_VERIFY_DEPOSIT: 300_000_000_000_000n,  // 300 Tgas
  UTXO_INIT_WITHDRAWAL: 100_000_000_000_000n, // 100 Tgas
  UTXO_VERIFY_WITHDRAWAL: 5_000_000_000_000n, // 5 Tgas
}

const DEPOSIT = {
  ONE_YOCTO: 1n,
}

// Proof schemas
EvmVerifyProofArgsSchema    // EVM proof arguments
WormholeVerifyProofArgsSchema // Wormhole VAA proof arguments
EvmProofSchema              // EVM proof structure

// Transaction argument schemas
FinTransferArgsSchema       // Finalization arguments
DeployTokenArgsSchema       // Deploy token arguments
BindTokenArgsSchema         // Bind token arguments
StorageDepositActionSchema  // Storage deposit action

// Enum schemas
ChainKindSchema             // ChainKind enum
ProofKindSchema             // ProofKind enum

import { FinTransferArgsSchema, ChainKind, ProofKind } from "@omni-bridge/near"

const serialized = FinTransferArgsSchema.serialize({
  chain_kind: ChainKind.Eth,
  storage_deposit_actions: [],
  prover_args: new Uint8Array([...]),
})