@anywalletkit/wallet-near 0.0.0-stage → 0.1.2

package/dist/index.d.cts

@@ -0,0 +1,677 @@
+import { IWalletAccountReadOnly, TransferResult, IWalletAccount, Signer, WalletManager, FeeRates } from '@anywalletkit/core';
+export { HistoryFetch, HistoryUnavailableError, NearChainTx, NearHistoryCursor, NearHistoryOptions, NearHistoryPage, NearHistoryRaw, NearHistorySource, NearblocksFtRow, NearblocksReceiptRow, NearblocksTxn, RpcTxStatus, createNearHistory, decodeFunctionCallArgs, decodeCursor as decodeHistoryCursor, encodeCursor as encodeHistoryCursor, mapNearblocksGroup, mapNearblocksTxn, mapRpcTxStatus, nearExplorerTxUrl, parseJsonPreservingBigInts } from './history.cjs';
+
+/** JSON-RPC transport: `method` + `params`, returns the `result` (throws on `error`). */
+type NearFetch = (method: string, params: unknown) => Promise<unknown>;
+/** One RPC base url (e.g. "https://free.rpc.fastnear.com") or a ready transport. */
+type NearProvider = string | NearFetch;
+/**
+ * Options for a NEAR wallet manager or account: RPC endpoints, network, fee caps and the
+ * pre-sign checks.
+ */
+interface NearConfig {
+    /** RPC url(s) / transport(s). A list fails over in order. Omit for an offline (sign-only) wallet. */
+    provider?: NearProvider | NearProvider[];
+    /** Extra attempts across the provider list after the first failure (default 3). */
+    retries?: number;
+    /** Optional headers for every request (e.g. an API key). */
+    headers?: Record<string, string>;
+    /** "mainnet" (default) | "testnet" | any CAIP-2 suffix. */
+    network?: 'mainnet' | 'testnet' | string;
+    /** Max fee (yoctoNEAR) for `transfer`. */
+    transferMaxFee?: bigint | number;
+    /** Max fee (yoctoNEAR) for `sendTransaction` / `signTransaction`. */
+    transactionMaxFee?: bigint | number;
+    /** Run the balance / account / access-key preflight before signing (default true). */
+    simulate?: boolean;
+    /**
+     * Allow actions that change the account itself or deploy code (AddKey, DeleteKey,
+     * DeleteAccount, DeployContract, Stake, CreateAccount, global-contract actions,
+     * SignedDelegate). Default false: they are refused with `dangerous-action`.
+     */
+    allowDangerousActions?: boolean;
+    /**
+     * Most yoctoNEAR a token `transfer` may attach as `storage_deposit` to register the
+     * recipient (the amount comes from the token contract itself). Default 0.0125 NEAR,
+     * ten times the usual NEP-145 minimum.
+     */
+    maxStorageDeposit?: bigint | number;
+}
+interface NearTransferAction {
+    transfer: {
+        deposit: bigint;
+    };
+}
+interface NearFunctionCallAction {
+    functionCall: {
+        methodName: string;
+        /** Raw bytes, or a JSON-serialisable object / string (encoded as UTF-8 JSON). */
+        args: Uint8Array | Record<string, unknown> | string;
+        /** Prepaid gas (default 30 Tgas). Max 300 Tgas. */
+        gas?: bigint;
+        /** Attached deposit in yoctoNEAR (default 0). */
+        deposit?: bigint;
+    };
+}
+interface NearCreateAccountAction {
+    createAccount: Record<string, never>;
+}
+interface NearDeployContractAction {
+    deployContract: {
+        code: Uint8Array;
+    };
+}
+interface NearStakeAction {
+    stake: {
+        stake: bigint;
+        publicKey: NearPublicKey;
+    };
+}
+/** An access key's nonce and permission (full access or a function-call key). */
+interface NearAccessKey {
+    nonce: bigint;
+    permission: {
+        fullAccess: Record<string, never>;
+    } | {
+        functionCall: {
+            allowance?: bigint;
+            receiverId: string;
+            methodNames: string[];
+        };
+    };
+}
+interface NearAddKeyAction {
+    addKey: {
+        publicKey: NearPublicKey;
+        accessKey: NearAccessKey;
+    };
+}
+interface NearDeleteKeyAction {
+    deleteKey: {
+        publicKey: NearPublicKey;
+    };
+}
+interface NearDeleteAccountAction {
+    deleteAccount: {
+        beneficiaryId: string;
+    };
+}
+interface NearDelegateAction {
+    senderId: string;
+    receiverId: string;
+    actions: NearAction[];
+    nonce: bigint;
+    maxBlockHeight: bigint;
+    publicKey: NearPublicKey;
+}
+interface NearSignedDelegateAction {
+    signedDelegate: {
+        delegateAction: NearDelegateAction;
+        signature: NearSignature;
+    };
+}
+interface NearDeployGlobalContractAction {
+    deployGlobalContract: {
+        code: Uint8Array;
+        deployMode: 'codeHash' | 'accountId';
+    };
+}
+interface NearUseGlobalContractAction {
+    useGlobalContract: {
+        codeHash: Uint8Array;
+    } | {
+        accountId: string;
+    };
+}
+/** One action of a NEAR transaction. */
+type NearAction = NearCreateAccountAction | NearDeployContractAction | NearFunctionCallAction | NearTransferAction | NearStakeAction | NearAddKeyAction | NearDeleteKeyAction | NearDeleteAccountAction | NearSignedDelegateAction | NearDeployGlobalContractAction | NearUseGlobalContractAction;
+/** A public key as NEAR encodes it: curve tag + raw bytes. */
+interface NearPublicKey {
+    keyType: 'ed25519' | 'secp256k1';
+    data: Uint8Array;
+}
+interface NearSignature {
+    keyType: 'ed25519' | 'secp256k1';
+    data: Uint8Array;
+}
+/**
+ * A transaction to sign. `signerId` / `publicKey` default to the account's; `nonce` /
+ * `blockHash` are fetched from the network when omitted (the account `needsNetwork`).
+ */
+interface NearTransaction {
+    receiverId: string;
+    actions: NearAction[];
+    signerId?: string;
+    publicKey?: NearPublicKey;
+    nonce?: bigint;
+    /** 32 bytes, or base58. */
+    blockHash?: Uint8Array | string;
+}
+/** Fully specified transaction as it is hashed and signed. */
+interface NearBuiltTransaction {
+    signerId: string;
+    publicKey: NearPublicKey;
+    nonce: bigint;
+    receiverId: string;
+    blockHash: Uint8Array;
+    actions: NearAction[];
+}
+interface NearSignedTransaction {
+    transaction: NearBuiltTransaction;
+    signature: NearSignature;
+}
+/** Shorthand for `transfer`: native NEAR (no `token`) or a NEP-141 token (`token` = contract account id). */
+interface NearTransferOptions {
+    token?: string;
+    recipient: string;
+    amount: bigint | number | string;
+    /** NEP-141 `memo` (ignored for native transfers — NEAR transfers carry no memo). */
+    memo?: string;
+}
+/** Gas a transaction may burn and its cost in yoctoNEAR. */
+interface NearFeeEstimate {
+    /** Gas the transaction can burn at most (prepaid function-call gas counts in full). */
+    gas: bigint;
+    /** yoctoNEAR per gas unit at quote time. */
+    gasPrice: bigint;
+    /** Upper bound of the fee in yoctoNEAR (`gas * gasPrice`, plus the account-creation charge when `createsAccount`). */
+    fee: bigint;
+    /** yoctoNEAR the actions attach (transfer deposits + function-call deposits). */
+    deposit: bigint;
+    /** True when a native transfer will create an implicit account (extra gas included). */
+    createsAccount: boolean;
+}
+/** Fee of a transaction in yoctoNEAR, with the estimate behind it. */
+interface NearQuote {
+    /** = `estimate.fee`. */
+    fee: bigint;
+    estimate: NearFeeEstimate;
+}
+/** Whether a transaction is expected to succeed, and why not. */
+interface NearSimulation {
+    ok: boolean;
+    reason?: string;
+}
+/** An account's balance, locked stake and storage. */
+interface NearAccountView {
+    amount: bigint;
+    locked: bigint;
+    storageUsage: bigint;
+    /** `amount - locked - storageUsage * STORAGE_PRICE_PER_BYTE` (never below 0). */
+    available: bigint;
+}
+/** Outcome of a NEAR transaction. */
+interface NearReceipt {
+    hash: string;
+    /** 1 success, 0 failed. */
+    status: 0 | 1;
+    blockNumber?: bigint;
+    /** Decoded failure, when any receipt failed. */
+    failure?: string;
+    /** Raw `tx` RPC payload. */
+    raw: Record<string, unknown>;
+}
+/** What a NEAR transaction does. */
+type NearTxKind = 'near-transfer' | 'ft-transfer' | 'ft-storage-deposit' | 'function-call' | 'batch' | 'create-account' | 'deploy-contract' | 'stake' | 'add-key' | 'delete-key' | 'delete-account' | 'delegate' | 'global-contract';
+/** Problems a NEAR description is flagged with. */
+type NearTxWarningCode = 'dangerous-action' | 'full-access-key' | 'zero-amount' | 'implicit-new-account' | 'self-transfer' | 'high-gas' | 'unknown-method' | 'invalid-account';
+/** One flagged problem, with a sentence a wallet can show. */
+interface NearTxWarning {
+    code: NearTxWarningCode;
+    message: string;
+}
+/** A NEAR transaction decoded for a confirmation screen. */
+interface NearTxDescription {
+    kind: NearTxKind;
+    warnings: NearTxWarning[];
+    /** Signer account id when known. */
+    from?: string;
+    /** Receiver account id (native transfer) or NEP-141 `receiver_id` (ft-transfer). */
+    to?: string;
+    /** yoctoNEAR (native) or token base units (ft-transfer). */
+    amount?: bigint;
+    /** NEP-141 contract account id. */
+    token?: string;
+    /** NEP-141 memo. */
+    memo?: string;
+    /** Called contract (function-call / batch). */
+    contract?: string;
+    /** Methods called, in order. */
+    methods?: string[];
+    /** Total yoctoNEAR attached across actions. */
+    deposit: bigint;
+    /** Total prepaid gas across function calls. */
+    gas: bigint;
+    actionCount: number;
+}
+/** CAIP-2 ids of NEAR mainnet and testnet. */
+declare const CAIP2: Record<string, string>;
+/** 1 NEAR = 10^24 yoctoNEAR. */
+declare const YOCTO: bigint;
+/** 1 Tgas. */
+declare const TGAS: bigint;
+/** Hard per-transaction prepaid gas limit. */
+declare const MAX_GAS: bigint;
+/** Protocol storage price: 10^19 yoctoNEAR per byte. */
+declare const STORAGE_PRICE_PER_BYTE: bigint;
+/** NEP-141 `ft_transfer` requires exactly 1 yoctoNEAR attached. */
+declare const ONE_YOCTO = 1n;
+/** Default gas for `ft_transfer` / `storage_deposit`. */
+declare const FT_TRANSFER_GAS: bigint;
+/** Gas attached to a NEP-145 `storage_deposit` call. */
+declare const STORAGE_DEPOSIT_GAS: bigint;
+/** Minimum native transfer that can create an implicit account (covers its storage). */
+declare const IMPLICIT_ACCOUNT_MIN_DEPOSIT: bigint;
+
+/** Why a transaction was refused before signing. */
+type UnsafeTransactionCode = 'signer-mismatch' | 'public-key-mismatch' | 'dangerous-action' | 'invalid-account' | 'no-actions' | 'gas-limit' | 'fee-limit' | 'missing-block-hash' | 'missing-nonce' | 'unknown-action' | 'insufficient-balance' | 'implicit-account-min-deposit' | 'no-access-key' | 'storage-deposit';
+/** A transaction failed a hard check and was not signed. */
+declare class UnsafeTransactionError extends Error {
+    readonly code: UnsafeTransactionCode;
+    constructor(code: UnsafeTransactionCode, message: string);
+}
+/** The preflight (balances, account, access key, token registration) predicted failure; nothing was signed. */
+declare class SimulationError extends Error {
+    readonly reason: string;
+    constructor(reason: string);
+}
+/** The RPC answered with an `error` object. */
+declare class NearRpcError extends Error {
+    readonly method: string;
+    readonly errorName: string | undefined;
+    readonly cause: unknown;
+    constructor(method: string, error: {
+        name?: string;
+        message?: string;
+        cause?: {
+            name?: string;
+            info?: unknown;
+        };
+        data?: unknown;
+        code?: number;
+    });
+}
+
+/** True for a valid NEAR account id: 2–64 characters of the allowed alphabet, implicit or named. */
+declare function isValidAccountId(id: string): boolean;
+/** 64 lowercase hex chars = an implicit account (the account id IS the ed25519 public key). */
+declare function isImplicitAccountId(id: string): boolean;
+/** The implicit account id of an ed25519 public key. */
+declare function implicitAccountId(publicKey: Uint8Array): string;
+/** "ed25519:<base58>" as NEAR tooling prints keys. */
+declare function publicKeyToString(k: NearPublicKey): string;
+/** Parse `ed25519:<base58>` (or bare base58) into a public key. */
+declare function parsePublicKey(s: string): NearPublicKey;
+/** A NEAR public key from 32 ed25519 bytes. */
+declare function ed25519Key(publicKey: Uint8Array): NearPublicKey;
+/** The ed25519 public key behind an implicit account id. */
+declare function publicKeyOfImplicit(accountId: string): Uint8Array;
+/** Decode base58, optionally checking the length. */
+declare function base58ToBytes(s: string, length?: number): Uint8Array;
+/** Encode bytes as base58. */
+declare const bytesToBase58: (b: Uint8Array) => string;
+
+/**
+ * Borsh (https://borsh.io) for NEAR transactions — the exact layout nearcore and
+ * @near-js/transactions use, written by hand so the package has no borsh dependency:
+ * little-endian integers, u32-length-prefixed strings / vectors, u8 enum tags.
+ */
+
+/** @internal Minimal borsh encoder for NEAR transactions. */
+declare class BorshWriter {
+    private _buf;
+    private _len;
+    private ensure;
+    u8(v: number): this;
+    u32(v: number): this;
+    uint(v: bigint, bytes: number): this;
+    u64(v: bigint): this;
+    u128(v: bigint): this;
+    bytes(b: Uint8Array): this;
+    /** Vec<u8> / String: u32 length + bytes. */
+    vecU8(b: Uint8Array): this;
+    string(s: string): this;
+    option<T>(v: T | undefined, write: (v: T) => void): this;
+    toBytes(): Uint8Array;
+}
+/** @internal Minimal borsh decoder for NEAR transactions. */
+declare class BorshReader {
+    private readonly _buf;
+    private _pos;
+    constructor(_buf: Uint8Array);
+    get remaining(): number;
+    private need;
+    u8(): number;
+    u32(): number;
+    uint(bytes: number): bigint;
+    u64(): bigint;
+    u128(): bigint;
+    bytes(n: number): Uint8Array;
+    vecU8(): Uint8Array;
+    string(): string;
+    option<T>(read: () => T): T | undefined;
+    done(): void;
+}
+declare function writePublicKey(w: BorshWriter, k: NearPublicKey): void;
+declare function readPublicKey(r: BorshReader): NearPublicKey;
+declare function writeSignature(w: BorshWriter, s: NearSignature): void;
+declare function readSignature(r: BorshReader): NearSignature;
+/** Enum order from nearcore `Action` (and @near-js/transactions SCHEMA.Action). */
+declare const ACTION_TAG: {
+    readonly createAccount: 0;
+    readonly deployContract: 1;
+    readonly functionCall: 2;
+    readonly transfer: 3;
+    readonly stake: 4;
+    readonly addKey: 5;
+    readonly deleteKey: 6;
+    readonly deleteAccount: 7;
+    readonly signedDelegate: 8;
+    readonly deployGlobalContract: 9;
+    readonly useGlobalContract: 10;
+};
+type NearActionKey = keyof typeof ACTION_TAG;
+declare function actionKey(a: NearAction): NearActionKey;
+/** Function-call args as bytes: raw bytes pass through; objects / strings become UTF-8 JSON / UTF-8. */
+declare function argsBytes(args: Uint8Array | Record<string, unknown> | string): Uint8Array;
+declare function writeAction(w: BorshWriter, a: NearAction): void;
+declare function readAction(r: BorshReader): NearAction;
+/** Borsh bytes of an unsigned transaction. */
+declare function encodeTransaction(tx: NearBuiltTransaction): Uint8Array;
+/** Decode an unsigned transaction from borsh bytes. */
+declare function decodeTransaction(bytes: Uint8Array): NearBuiltTransaction;
+/** Borsh bytes of a signed transaction, ready to broadcast as base64. */
+declare function encodeSignedTransaction(s: NearSignedTransaction): Uint8Array;
+/** Decode a signed transaction from borsh bytes. */
+declare function decodeSignedTransaction(bytes: Uint8Array): NearSignedTransaction;
+/** Unsigned or signed borsh bytes → the transaction (and signature when present). */
+declare function decodeAnyTransaction(bytes: Uint8Array): {
+    transaction: NearBuiltTransaction;
+    signature?: NearSignature;
+};
+
+/** Base64 helpers that work in Node, browsers and Hermes (no Buffer). */
+declare function toBase64(bytes: Uint8Array): string;
+declare function fromBase64(s: string): Uint8Array;
+/** One transport, or a failover transport over the list. */
+declare function createClient(config: NearConfig): NearFetch | undefined;
+interface RawAccountView {
+    amount: string;
+    locked: string;
+    storage_usage: number;
+    code_hash?: string;
+    block_height?: number;
+    block_hash?: string;
+}
+interface RawAccessKeyView {
+    nonce: number;
+    permission: 'FullAccess' | {
+        FunctionCall: {
+            allowance: string | null;
+            receiver_id: string;
+            method_names: string[];
+        };
+    };
+    block_hash?: string;
+    block_height?: number;
+}
+interface RawFinalOutcome {
+    status?: Record<string, unknown>;
+    final_execution_status?: string;
+    transaction?: {
+        hash?: string;
+        signer_id?: string;
+    };
+    transaction_outcome?: {
+        id?: string;
+        block_hash?: string;
+        outcome?: {
+            status?: Record<string, unknown>;
+            gas_burnt?: number;
+            tokens_burnt?: string;
+        };
+    };
+    receipts_outcome?: Array<{
+        id?: string;
+        block_hash?: string;
+        outcome?: {
+            status?: Record<string, unknown>;
+            gas_burnt?: number;
+            tokens_burnt?: string;
+        };
+    }>;
+}
+/** The NEAR JSON-RPC calls a wallet uses, with parsed results. */
+declare class NearRpc {
+    readonly fetch: NearFetch;
+    constructor(fetch: NearFetch);
+    /** `undefined` when the account does not exist. */
+    viewAccount(accountId: string): Promise<RawAccountView | undefined>;
+    /** `undefined` when the key is not on the account. */
+    viewAccessKey(accountId: string, publicKey: string): Promise<RawAccessKeyView | undefined>;
+    /** View call; the JSON-decoded return value (`null` for an empty result). */
+    callFunction<T = unknown>(contract: string, method: string, args?: Record<string, unknown>): Promise<T>;
+    latestBlockHash(): Promise<string>;
+    gasPrice(): Promise<bigint>;
+    sendTx(signedTxBase64: string, waitUntil?: 'NONE' | 'INCLUDED' | 'EXECUTED_OPTIMISTIC' | 'INCLUDED_FINAL' | 'EXECUTED' | 'FINAL'): Promise<RawFinalOutcome>;
+    /** `undefined` when the node does not know the transaction. */
+    txStatus(hash: string, senderId: string): Promise<RawFinalOutcome | undefined>;
+}
+/** Human-readable failure from an execution `status` (`{Failure: {...}}`), or undefined on success. */
+declare function failureOf(status: Record<string, unknown> | undefined): string | undefined;
+/** Did the whole transaction (every receipt) succeed? */
+declare function outcomeFailed(o: RawFinalOutcome): string | undefined;
+
+/** What an offline description can be told to sharpen its warnings. */
+interface DescribeContext {
+    /** The signing account; adds `self-transfer` and fills `from`. */
+    signerId?: string;
+    /** Whether the receiver account exists; `describeTransactionOnline` fills it from the node. */
+    recipientExists?: boolean;
+}
+/** Actions that change the account itself, its keys, or deploy code. Refused unless `allowDangerousActions`. */
+declare const DANGEROUS_ACTIONS: Set<string>;
+/** What a transaction does, decoded offline. Never throws on odd input — it warns. */
+declare function describeTransaction(tx: NearTransaction, ctx?: DescribeContext): NearTxDescription;
+/**
+ * True for actions that change who controls the account or its code: keys, account creation
+ * or deletion, contract deployment, staking, delegated actions. Refused unless
+ * `allowDangerousActions` is set.
+ */
+declare const isDangerous: (a: NearAction) => boolean;
+
+/** NEP-413 tag (2^31 + 413) that keeps a signed message from being a valid transaction. */
+declare const NEP413_PREFIX: number;
+/** A NEP-413 sign-in message, as a site asks for it. */
+interface Nep413Payload {
+    message: string;
+    /** 32 random bytes chosen by the verifier (replay protection). */
+    nonce: Uint8Array;
+    /** Who the message is for (e.g. "intents.near"). */
+    recipient: string;
+    callbackUrl?: string;
+}
+/** A NEP-413 signature and the key that made it. */
+interface Nep413Signed {
+    /** Base64 of the 64-byte ed25519 signature — the encoding wallets return. */
+    signature: string;
+    /** "ed25519:<base58>" */
+    publicKey: string;
+    accountId: string;
+}
+/** Borsh bytes of a NEP-413 payload, ready to hash and sign. */
+declare function nep413Bytes(p: Nep413Payload): Uint8Array;
+/** The 32-byte digest an ed25519 signer signs for a NEP-413 message. */
+declare function nep413Hash(p: Nep413Payload): Uint8Array;
+
+/**
+ * A NEAR account without a key: balances, NEP-141 tokens and storage, fee estimates, simulation,
+ * receipts and signature checks.
+ */
+declare class WalletAccountReadOnlyNear implements IWalletAccountReadOnly {
+    /** Account id: the implicit hex id of the key, or a named account bound to it. */
+    readonly address: string;
+    readonly chain: string;
+    readonly publicKey: NearPublicKey;
+    protected readonly _config: NearConfig;
+    protected readonly _client: NearFetch | undefined;
+    protected readonly _rpc: NearRpc | undefined;
+    /**
+     * @param address account id; an implicit (64-hex) id also fixes the public key.
+     * @param publicKey required for a named account (the key the account signs with).
+     */
+    constructor(address: string, config?: NearConfig, publicKey?: Uint8Array | NearPublicKey);
+    /** "ed25519:<base58>" */
+    get publicKeyString(): string;
+    protected requireRpc(what: string): NearRpc;
+    /** The account id. */
+    getAddress(): Promise<string>;
+    /** The account as the node sees it; `undefined` when it does not exist yet. */
+    getAccountView(accountId?: string): Promise<NearAccountView | undefined>;
+    /** Total NEAR balance in yoctoNEAR (0 for an account that does not exist yet). */
+    getBalance(): Promise<bigint>;
+    /** What can actually be spent: total − locked (staked) − storage reservation. */
+    getAvailableBalance(): Promise<bigint>;
+    /** True when the account exists on chain. */
+    accountExists(accountId: string): Promise<boolean>;
+    /** NEP-141 `ft_balance_of`. */
+    getTokenBalance(token: string): Promise<bigint>;
+    /** Several NEP-141 balances in parallel, keyed by the token contracts as given. */
+    getTokenBalances(tokens: string[]): Promise<Record<string, bigint>>;
+    /** NEP-145 storage registration of `accountId` on a token contract (`null` = not registered). */
+    getStorageBalance(token: string, accountId?: string): Promise<{
+        total: bigint;
+        available: bigint;
+    } | null>;
+    /** Minimum deposit a token contract wants for a registration (`storage_balance_bounds.min`). */
+    getStorageDepositMin(token: string): Promise<bigint>;
+    /**
+     * The actions for `transfer`: native → one Transfer; NEP-141 → `ft_transfer` (1 yocto, 30 Tgas),
+     * preceded by `storage_deposit` when the recipient is not registered on the token.
+     */
+    transferActions(o: NearTransferOptions): Promise<{
+        receiverId: string;
+        actions: NearAction[];
+    }>;
+    /** Fill `signerId` / `publicKey` / `nonce` / `blockHash` (the last two from the node when missing). */
+    buildTransaction(tx: NearTransaction | string): Promise<NearBuiltTransaction>;
+    /** Gas upper bound for the actions (prepaid function-call gas in full). */
+    static gasOf(actions: NearAction[], createsAccount: boolean): bigint;
+    static depositOf(actions: NearAction[]): bigint;
+    protected estimate(tx: Pick<NearBuiltTransaction, 'receiverId' | 'actions'>, recipientExists?: boolean): Promise<NearFeeEstimate>;
+    /** Gas and cost of a transaction. */
+    estimateFee(tx: NearTransaction | string): Promise<NearFeeEstimate>;
+    /** Fee of a transaction in yoctoNEAR. */
+    quoteSendTransaction(tx: NearTransaction | string): Promise<NearQuote>;
+    /** Fee of a transfer in yoctoNEAR, for the same actions `transfer` would send. */
+    quoteTransfer(o: NearTransferOptions): Promise<NearQuote>;
+    /**
+     * Predict failure without signing: the signer account and its access key exist,
+     * the spendable balance covers deposits + fee, a named recipient exists (an
+     * implicit one may be created, for ≥ 0.002 NEAR), the token balance covers an
+     * `ft_transfer`. Transport failures throw; predicted failures don't.
+     */
+    simulateTransaction(tx: NearBuiltTransaction | NearTransaction, estimate?: NearFeeEstimate): Promise<NearSimulation>;
+    /**
+     * Refuse what cannot be right: a foreign signer or key, no actions, a dangerous
+     * action (unless `allowDangerousActions`), an invalid receiver, prepaid gas over
+     * 300 Tgas, a fee above `transactionMaxFee`.
+     */
+    assertSafe(tx: NearBuiltTransaction, fee?: bigint): void;
+    /** `describeTransaction` plus the recipient-existence check against the node. */
+    describeTransactionOnline(tx: NearTransaction, ctx?: DescribeContext): Promise<NearTxDescription>;
+    /** Status of one of this account's transactions (the `tx` RPC needs the sender). */
+    getTransactionReceipt(hash: string): Promise<NearReceipt | undefined>;
+    /** Verify an `ed25519:<base58>` (or bare base58 / hex) signature produced by `sign`. */
+    verify(message: string | Uint8Array, signature: string): Promise<boolean>;
+    /** sha256(borsh(tx)) — what gets signed; base58 of it is the transaction hash. */
+    static hashOf(tx: NearBuiltTransaction): Uint8Array;
+    static txHash(tx: NearBuiltTransaction): string;
+}
+declare function receiptOf(hash: string, o: RawFinalOutcome): NearReceipt;
+declare function parseSignature(signature: string): Uint8Array;
+
+interface NearTransferResult extends TransferResult {
+    estimate?: NearFeeEstimate;
+}
+/**
+ * Signing NEAR account. The key lives in an ed25519 {@link Signer} (a local key
+ * zeroized by `dispose()`, or an external hardware / MPC / backend signer). The
+ * account builds the transaction (nonce + block hash from the node), checks it,
+ * runs the preflight, has the signer sign sha256(borsh(tx)) (context `near-tx`)
+ * and broadcasts it with `send_tx`.
+ *
+ * By default the account id is the implicit one (hex of the public key). Pass
+ * `accountId` for a named account whose full-access key this is.
+ */
+declare class WalletAccountNear extends WalletAccountReadOnlyNear implements IWalletAccount {
+    /** nonce / block hash come from the node, so building needs the network. */
+    readonly needsNetwork = true;
+    /** Derivation path, or `external` for an external signer. */
+    readonly path: string;
+    /** The signer that holds the key. */
+    readonly signer: Signer;
+    private _disposed;
+    private _readOnly;
+    constructor(signer: Signer, publicKey: Uint8Array, path: string, config?: NearConfig, accountId?: string);
+    /** Wrap a raw derived key (takes ownership; zeroized on dispose). */
+    static fromPrivateKey(privateKey: Uint8Array, publicKey: Uint8Array, path: string, config?: NearConfig, accountId?: string): WalletAccountNear;
+    /** Account index for the standard m/44'/397'/i' path. */
+    get index(): number | undefined;
+    /** The same key bound to a named account (`alice.near`) that lists it as a full-access key. */
+    withAccountId(accountId: string): WalletAccountNear;
+    private key;
+    private signBytes;
+    /** Raw ed25519 signature over the message bytes, as NEAR tooling prints it: "ed25519:<base58>". */
+    sign(message: string | Uint8Array): Promise<string>;
+    /** NEP-413 off-chain message (what NEAR Intents and dApps ask wallets to sign). */
+    signNep413(payload: Nep413Payload): Promise<Nep413Signed>;
+    /** Sign a fully built transaction. No checks — see `signTransaction`. */
+    signBuilt(tx: NearBuiltTransaction): Promise<NearSignedTransaction>;
+    /** Build → hard checks → preflight → fee cap. Shared by sign / send / transfer. */
+    private prepare;
+    /** Build, check, preflight and sign; returns the signed transaction as base64 borsh (what `send_tx` takes). */
+    signTransaction(tx: NearTransaction | string): Promise<string>;
+    private broadcast;
+    /**
+     * Sign and broadcast. Accepts a transaction, or base64 borsh of an unsigned /
+     * already-signed transaction (a signed one is checked, not re-signed).
+     */
+    sendTransaction(tx: NearTransaction | string): Promise<NearTransferResult>;
+    /** Native NEAR (no `token`) or NEP-141 `ft_transfer` (with `storage_deposit` when the recipient needs it). */
+    transfer(o: NearTransferOptions): Promise<NearTransferResult>;
+    /** The same account as a {@link WalletAccountReadOnlyNear}. */
+    toReadOnlyAccount(): IWalletAccountReadOnly;
+    /** Dispose the signer (zeroizes a local key). Idempotent. */
+    dispose(): void;
+}
+
+/** Base derivation path; account `i` is at `m/44'/397'/i'`. */
+declare const NEAR_BASE_PATH = "m/44'/397'";
+/**
+ * One seed → NEAR accounts at m/44'/397'/i' (SLIP-10 ed25519 — the NEAR Wallet /
+ * near-seed-phrase path; index 0 is what every NEAR wallet derives). Paths may be
+ * given relative to m/44'/397' ("0'") or in full; every segment must be hardened.
+ *
+ * Built with an ed25519 `Signer` instead of a seed, the manager wraps it:
+ * - a derivable `SeedSigner` sitting at `m/44'/397'` yields `getAccount(i)` → `i'` children;
+ * - a `SeedSigner` at a leaf, or any external signer, is `getAccount(0)` (path = the
+ *   signer's path, or 'external'); other indexes/paths throw `SignerError`.
+ *
+ * `getNamedAccount("alice.near", i)` binds account i's key to a named account.
+ */
+declare class WalletManagerNear extends WalletManager<WalletAccountNear, NearConfig> {
+    constructor(seedOrSigner: string | Uint8Array | Signer, config?: NearConfig);
+    getAccount(index?: number): Promise<WalletAccountNear>;
+    getAccountByPath(path: string): Promise<WalletAccountNear>;
+    /** The key of account `index`, bound to a named account that lists it as a full-access key. */
+    getNamedAccount(accountId: string, index?: number): Promise<WalletAccountNear>;
+    /** Resolve `path` against an injected signer: the signer itself, or a child when it can derive there. */
+    private fromSigner;
+    /** A read-only account for any account id, with this manager's config. */
+    getReadOnlyAccount(accountId: string, publicKey?: Uint8Array | NearPublicKey): WalletAccountReadOnlyNear;
+    /** NEAR has one protocol gas price (`gas_price` RPC, yoctoNEAR per gas); it can rise ~1%/block, so fast = ×1.1. */
+    getFeeRates(): Promise<FeeRates>;
+}
+
+export { ACTION_TAG, BorshReader, BorshWriter, CAIP2, DANGEROUS_ACTIONS, type DescribeContext, FT_TRANSFER_GAS, IMPLICIT_ACCOUNT_MIN_DEPOSIT, MAX_GAS, NEAR_BASE_PATH, NEP413_PREFIX, type NearAccessKey, type NearAccountView, type NearAction, type NearAddKeyAction, type NearBuiltTransaction, type NearConfig, type NearCreateAccountAction, type NearDelegateAction, type NearDeleteAccountAction, type NearDeleteKeyAction, type NearDeployContractAction, type NearDeployGlobalContractAction, type NearFeeEstimate, type NearFetch, type NearFunctionCallAction, type NearProvider, type NearPublicKey, type NearQuote, type NearReceipt, NearRpc, NearRpcError, type NearSignature, type NearSignedDelegateAction, type NearSignedTransaction, type NearSimulation, type NearStakeAction, type NearTransaction, type NearTransferAction, type NearTransferOptions, type NearTransferResult, type NearTxDescription, type NearTxKind, type NearTxWarning, type NearTxWarningCode, type NearUseGlobalContractAction, type Nep413Payload, type Nep413Signed, ONE_YOCTO, STORAGE_DEPOSIT_GAS, STORAGE_PRICE_PER_BYTE, SimulationError, TGAS, type UnsafeTransactionCode, UnsafeTransactionError, WalletAccountNear, WalletAccountReadOnlyNear, WalletManagerNear, YOCTO, actionKey, argsBytes, base58ToBytes, bytesToBase58, createClient, decodeAnyTransaction, decodeSignedTransaction, decodeTransaction, WalletManagerNear as default, describeTransaction, ed25519Key, encodeSignedTransaction, encodeTransaction, failureOf, fromBase64, implicitAccountId, isDangerous, isImplicitAccountId, isValidAccountId, nep413Bytes, nep413Hash, outcomeFailed, parsePublicKey, parseSignature, publicKeyOfImplicit, publicKeyToString, readAction, readPublicKey, readSignature, receiptOf, toBase64, writeAction, writePublicKey, writeSignature };