near-api-js 7.0.2 → 7.0.4

package/README.md

@@ -2,7 +2,24 @@
 
 NEAR JavaScript API is a complete library to interact with the NEAR blockchain. You can use it in the browser, or in Node.js runtime.
 
-## Installation
+> [!IMPORTANT]  
+> `near-api-js` is ideal to build backend services, CLIs, and scripts that interact with NEAR. For frontend development please check the official [web login docs](https://docs.near.org/web3-apps/concepts/web-login)
+
+## Why near-api-js?
+
+**near-api-js v7** is a single package that helps you to easily integrate NEAR blockchain into your JavaScript/TypeScript applications.
+
+It includes all the functionality you need, including account management, transaction building, key management, interacting with smart contracts, making RPC calls, and more.
+
+- ✅ Simple - just one package
+- ✅ Batteries included - everything you need to build scripts and backend services
+- ✅ Friendly - multiple helpers to make your life easier
+- ✅ Full TypeScript support
+- ✅ Works in browser and Node.js
+
+## Quick Start
+
+Add `near-api-js` to your project using your favorite package manager:
 
 ```bash
 npm install near-api-js
@@ -12,19 +29,78 @@ yarn add near-api-js
 pnpm add near-api-js
 ```
 
-## Why near-api-js?
+Start using it!
 
-Previously, NEAR JavaScript functionality was split across multiple `@near-js/*` packages. While this modular approach is great for tree-shaking, it made it difficult for developers to know which packages they needed.
+```ts
+import { Account, JsonRpcProvider, teraToGas, KeyPairString, nearToYocto } from "near-api-js";
 
-**near-api-js v7** goes back to be a single package that includes all NEAR JavaScript functionality, making it easier to get started and use NEAR in your projects:
-- ✅ Simple installation - just one package
-- ✅ Easy imports - everything in one place
-- ✅ Full TypeScript support
-- ✅ Works in browser and Node.js
+// Create a testnet provider
+const provider = new JsonRpcProvider({
+  url: "https://test.rpc.fastnear.com",
+});
+
+// For read only calls, you can use the provider directly
+const messages = await provider.callFunction({
+  contractId: 'guestbook.near-examples.testnet',
+  method: "get_messages",
+  args: {},
+});
+
+console.log(messages);
+
+// To modify state, you need an account to sign the transaction
+const accountId: string = 'example.testnet';
+const privateKey = 'ed25519:5nM...' as KeyPairString;
+const account = new Account(accountId, provider, privateKey);
+
+// Call the contract
+await account.callFunction({
+  contractId: 'guestbook.near-examples.testnet',
+  methodName: "add_message",
+  args: { text: "Hello!" },
+  gas: teraToGas('30'),
+  deposit: nearToYocto('0.1'),
+});
+```
 
-## Quick Start
+## Documentation
+
+- [Learn how to use](https://docs.near.org/tools/near-api) the library in your project
+- See it in action in our [API Examples](https://github.com/near-examples/near-api-examples/tree/main/near-api-js)
+- Read the [TypeDoc API](https://near.github.io/near-api-js/) documentation
+
+## Migration from @near-js/* packages
+
+Check out the [migration guide](MIGRATION.md) to help you move from the old `@near-js/*` packages to `near-api-js`.
+
+## Features
 
-### Basic Example
+`near-api-js` includes some advanced features to help you build robust applications.
+
+### Simple Units Conversions
+
+You can easily convert between NEAR and yoctoNEAR, and between gas units:
+
+```typescript
+import { nearToYocto, yoctoToNear, teraToGas, gigaToGas } from 'near-api-js';
+
+await account.callFunction({
+  contractId: 'example.testnet',
+  methodName: 'some_method',
+  args: {},
+  gas: teraToGas('30'),         // 30 TeraGas
+  deposit: nearToYocto('0.1'),  // 0.1 NEAR
+});
+
+// balance in NEAR with 2 decimals
+const balance = yoctoToNear(await account.getBalance(), 2);
+
+```
+
+### Parallel Transactions
+`near-api-js` can send transactions in parallel by rotating multiple keys for an account.
+
+`nonce` collisions are automatically handled by retrying with incremented nonce.
 
 ```typescript
 import { Account, actions, JsonRpcProvider, KeyPair, MultiKeySigner } from "near-api-js"
@@ -80,69 +156,36 @@ const sendNearTokensResults = await Promise.all(transfers)
 sendNearTokensResults.forEach(result => console.log(result))
 ```
 
-### Working with Contracts
+### Typescript Support
+
+`near-api-js` is written in `TypeScript` and includes full type definitions:
 
 ```typescript
-import { Contract } from 'near-api-js';
-
-const contract = new Contract(
-  account, // the account object that is connecting
-  'contract-id.testnet',
-  {
-    viewMethods: ['get_status'],
-    changeMethods: ['set_status'],
-  }
-);
-
-// Call methods
-const status = await contract.get_status();
-await contract.set_status({ message: 'Hello NEAR!' });
+import type {
+  AccountView,
+  BlockReference,
+  Action,
+  SignedTransaction
+} from 'near-api-js';
 ```
 
-## What's Included
-
-near-api-js includes all NEAR JavaScript functionality:
-
-- **Accounts** - Account management and contract interactions
-- **Crypto** - Key pair generation, signing, and verification
-- **Transactions** - Transaction creation and signing
-- **Providers** - RPC providers with failover support
-- **Keystores** - Secure key storage for browser and Node.js
-- **Signers** - Transaction signing interfaces
-- **Types** - Full TypeScript type definitions
-- **Utils** - Formatting, parsing, and helper functions
-- **Tokens** - FT and NFT standard support
-- **Biometric Auth** - WebAuthn support for passwordless auth
-- **IFrame RPC** - Wallet integration helpers
+### Typed Function Calls
 
-## Documentation
-
-- [Learn how to use](https://docs.near.org/tools/near-api-js/quick-reference) the library in your project
-- Read the [TypeDoc API](https://near.github.io/near-api-js/) documentation
-- [Cookbook](https://github.com/near/near-api-js/blob/master/packages/cookbook/README.md) with common use cases
-- To quickly get started with integrating NEAR in a _web browser_, read our [Web Frontend integration](https://docs.near.org/develop/integrate/frontend) article
-
-## Migration from @near-js/* packages
+You can even type the expected results from contract function calls:
 
-If you were previously using individual `@near-js/*` packages, migration is straightforward:
-
-**Before:**
 ```typescript
-import { Account } from '@near-js/accounts';
-import { KeyPair } from '@near-js/crypto';
-import { JsonRpcProvider } from '@near-js/providers';
-```
+const provider = new JsonRpcProvider({
+  url: "https://test.rpc.fastnear.com",
+});
+const account = new Account("accountId", provider, "privateKey");
 
-**After:**
-```typescript
-import { Account, KeyPair, JsonRpcProvider } from 'near-api-js';
+await provider.callFunction<T>()
+await account.callFunction<T>()
 ```
 
-All exports remain the same - just change the import source!
+### Failover RPC Provider
 
-## Advanced Usage
-
-### Custom RPC Provider
+You can easily define multiple RPC endpoints to connect to  NEAR network, if one fails the next one will be used automatically.
 
 ```typescript
 import { JsonRpcProvider, FailoverRpcProvider } from 'near-api-js';
@@ -153,45 +196,37 @@ const provider = new FailoverRpcProvider([
 ]);
 ```
 
-### Transaction Building
-
-```typescript
-import {
-  actions as actionCreators,
-  createTransaction,
-  signTransaction
-} from 'near-api-js';
-
-const { transfer, functionCall } = actionCreators;
-
-const actions = [
-  transfer(BigInt('1000000000000000000000000')), // 1 NEAR
-  functionCall('method_name', { arg: 'value' }, BigInt('30000000000000'), BigInt('0'))
-];
-
-const transaction = createTransaction(
-  'sender.near',
-  publicKey,
-  'receiver.near',
-  nonce,
-  actions,
-  blockHash
-);
-
-const signedTx = await signTransaction(transaction, signer, 'sender.near', networkId);
-```
-
-## TypeScript Support
+### Decoupled Transaction Signing
+You can separately build transactions, sign them, and broadcast them to the network.
 
-near-api-js is written in TypeScript and includes full type definitions:
+This is useful in scenarios where signing and sending need to be decoupled, such as offline signing
 
 ```typescript
-import type {
-  AccountView,
-  BlockReference,
-  Action,
-  SignedTransaction
-} from 'near-api-js';
+import { JsonRpcProvider, Account, KeyPairSigner, actions, nearToYocto, KeyPairString } from "near-api-js";
+
+const provider = new JsonRpcProvider({
+  url: "https://test.rpc.fastnear.com",
+});
+
+// You can create a transaction only knowing the accountId and public key
+const publicKey = '';
+const accountId = '';
+const account = new Account(accountId, provider);
+
+const transaction = await account.createTransaction({
+  receiverId: "receiver-account.testnet",
+  actions: [actions.transfer(nearToYocto("0.1"))],
+  publicKey: publicKey
+});
+
+// Whoever holds the private key can sign the transaction
+const signer = KeyPairSigner.fromSecretKey(privateKey as KeyPairString);
+const signResult = await signer.signTransaction(transaction);
+console.log(signResult.signedTransaction);
+
+// Anybody can send the signed transaction to the network
+const sendTransactionResult = await provider.sendTransaction(signResult.signedTransaction);
+console.log(sendTransactionResult);
 ```
 
 ## Browser and Node.js Support
@@ -214,20 +249,12 @@ Contributions are welcome! Please check out the [contributing guidelines](https:
 
        pnpm -r compile -w
 
-### Publish
-
-Prepare `dist` version by running:
-
-    pnpm dist
-
 ### Integration Test
 
-Start the node by following instructions from [nearcore](https://github.com/nearprotocol/nearcore), then
+Simply run:
 
     pnpm test
 
-Tests use sample contract from `near-hello` npm package, see https://github.com/nearprotocol/near-hello
-
 ## License
 
 This repository is distributed under the terms of both the MIT license and the Apache License (Version 2.0).

package/lib/accounts/account.d.ts

@@ -143,9 +143,10 @@ export declare class Account {
     /**
      * Create a transaction that can be later signed with a {@link Signer}
      *
-     * @param receiverId Account against which to perform the actions
-     * @param actions Actions to perform
-     * @param publicKey The public part of the key that will be used to sign the transaction
+     * @param options Transaction options
+     * @param options.receiverId Account against which to perform the actions
+     * @param options.actions Actions to perform
+     * @param options.publicKey The public part of the key that will be used to sign the transaction
      */
     createTransaction({ receiverId, actions, publicKey }: CreateTransactionArgs): Promise<import("../transactions/schema.js").Transaction>;
     /**
@@ -155,25 +156,28 @@ export declare class Account {
     /**
      * Create a meta transaction ready to be signed by a {@link Signer}
      *
-     * @param receiverId NEAR account receiving the transaction
-     * @param actions list of actions to perform as part of the meta transaction
-     * @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
+     * @param options Meta transaction options
+     * @param options.receiverId NEAR account receiving the transaction
+     * @param options.actions list of actions to perform as part of the meta transaction
+     * @param options.blockHeightTtl number of blocks after which a meta transaction will expire if not processed
      */
     createMetaTransaction({ receiverId, actions, blockHeightTtl, publicKey, }: CreateMetaTransactionArgs): Promise<DelegateAction>;
     /**
      * Create a signed MetaTransaction that can be broadcasted to a relayer
      *
-     * @param receiverId NEAR account receiving the transaction
-     * @param actions list of actions to perform as part of the meta transaction
-     * @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
+     * @param options Signed meta transaction options
+     * @param options.receiverId NEAR account receiving the transaction
+     * @param options.actions list of actions to perform as part of the meta transaction
+     * @param options.blockHeightTtl number of blocks after which a meta transaction will expire if not processed
      */
     createSignedMetaTransaction({ receiverId, actions, blockHeightTtl, signer, }: CreateSignedMetaTransactionArgs): Promise<SignDelegateActionReturn>;
     /**
      * Creates a transaction, signs it and broadcast it to the network
      *
-     * @param receiverId The NEAR account ID of the transaction receiver.
-     * @param actions The list of actions to be performed in the transaction.
-     * @param throwOnFailure Whether to throw an error if the transaction fails.
+     * @param options Sign and send transaction options
+     * @param options.receiverId The NEAR account ID of the transaction receiver.
+     * @param options.actions The list of actions to be performed in the transaction.
+     * @param options.throwOnFailure Whether to throw an error if the transaction fails.
      *
      */
     signAndSendTransaction({ receiverId, actions, waitUntil, throwOnFailure, signer, retries, }: SignAndSendTransactionArgs): Promise<RpcTransactionResponse>;
@@ -189,9 +193,10 @@ export declare class Account {
      *    - The new account ID must end with the current account ID
      *    - Example: If your account is `ana.near`, you can create `sub.ana.near`
      *
-     * @param newAccountId the new account to create (e.g. bob.near or sub.ana.near)
-     * @param publicKey the public part of the key that will control the account
-     * @param nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
+     * @param options Account creation options
+     * @param options.newAccountId the new account to create (e.g. bob.near or sub.ana.near)
+     * @param options.publicKey the public part of the key that will control the account
+     * @param options.nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
      *
      */
     createAccount({ newAccountId, publicKey, nearToTransfer }: CreateAccountArgs): Promise<RpcTransactionResponse>;
@@ -199,9 +204,10 @@ export declare class Account {
      * Creates a sub account of this account. For example, if the account is
      * ana.near, you can create sub.ana.near.
      *
-     * @param accountOrPrefix a prefix (e.g. `sub`) or the full sub-account (`sub.ana.near`)
-     * @param publicKey the public part of the key that will control the account
-     * @param nearToTransfer how much NEAR to transfer to the account (default: 0)
+     * @param options Sub-account creation options
+     * @param options.accountOrPrefix a prefix (e.g. `sub`) or the full sub-account (`sub.ana.near`)
+     * @param options.publicKey the public part of the key that will control the account
+     * @param options.nearToTransfer how much NEAR to transfer to the account (default: 0)
      *
      */
     createSubAccount({ accountOrPrefix, publicKey, nearToTransfer }: CreateSubAccountArgs): Promise<RpcTransactionResponse>;
@@ -260,26 +266,26 @@ export declare class Account {
     /**
      * Call a function on a smart contract and return parsed transaction result
      *
-     * @param options
-     * @param options.contractId The contract in which to call the function
-     * @param options.methodName The method that will be called
-     * @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
-     * @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
-     * @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
-     * @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
+     * @param params Call function parameters
+     * @param params.contractId The contract in which to call the function
+     * @param params.methodName The method that will be called
+     * @param params.args Arguments, either as a valid JSON Object or a raw Uint8Array
+     * @param params.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
+     * @param params.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
+     * @param params.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
      * @returns
      */
     callFunction<T extends SerializedReturnValue>(params: CallFunctionArgs): Promise<T>;
     /**
      * Call a function on a smart contract and return raw transaction outcome
      *
-     * @param options
-     * @param options.contractId The contract in which to call the function
-     * @param options.methodName The method that will be called
-     * @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
-     * @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
-     * @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
-     * @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
+     * @param params Call function parameters
+     * @param params.contractId The contract in which to call the function
+     * @param params.methodName The method that will be called
+     * @param params.args Arguments, either as a valid JSON Object or a raw Uint8Array
+     * @param params.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
+     * @param params.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
+     * @param params.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
      */
     callFunctionRaw({ contractId, methodName, args, deposit, gas, waitUntil, }: CallFunctionArgs): Promise<RpcTransactionResponse>;
     /**
@@ -287,11 +293,11 @@ export declare class Account {
      *
      * @deprecated This method is deprecated and will be removed in future versions. Please use `signMessage` from `near-api-js/nep413` to sign NEP-413 messages.
      *
-     * @param options
-     * @param options.message The message to be signed (e.g. "authenticating")
-     * @param options.recipient Who will receive the message (e.g. auth.app.com)
-     * @param options.nonce A challenge sent by the recipient
-     * @param options.callbackUrl (optional) Deprecated parameter used only by browser wallets
+     * @param args Nep413 message signing arguments
+     * @param args.message The message to be signed (e.g. "authenticating")
+     * @param args.recipient Who will receive the message (e.g. auth.app.com)
+     * @param args.nonce A challenge sent by the recipient
+     * @param args.callbackUrl (optional) Deprecated parameter used only by browser wallets
      * @returns
      */
     signNep413Message({ message, recipient, nonce, callbackUrl, }: SignNep413MessageArgs): Promise<SignedMessage>;
@@ -306,9 +312,10 @@ export declare class Account {
      *
      * Supports sending either the native NEAR token or any supported Fungible Token (FT).
      *
-     * @param amount - The amount of tokens to transfer in units (e.g. yoctoNEAR).
-     * @param receiverId - The NEAR account ID of the receiver.
-     * @param token - The token to transfer. Defaults to Native NEAR.
+     * @param options Transfer options
+     * @param options.amount - The amount of tokens to transfer in units (e.g. yoctoNEAR).
+     * @param options.receiverId - The NEAR account ID of the receiver.
+     * @param options.token - The token to transfer. Defaults to Native NEAR.
      *
      */
     transfer({ receiverId, amount, token }: TransferArgs): Promise<RpcTransactionResponse>;

package/lib/accounts/account.js

@@ -133,9 +133,10 @@ export class Account {
     /**
      * Create a transaction that can be later signed with a {@link Signer}
      *
-     * @param receiverId Account against which to perform the actions
-     * @param actions Actions to perform
-     * @param publicKey The public part of the key that will be used to sign the transaction
+     * @param options Transaction options
+     * @param options.receiverId Account against which to perform the actions
+     * @param options.actions Actions to perform
+     * @param options.publicKey The public part of the key that will be used to sign the transaction
      */
     async createTransaction({ receiverId, actions, publicKey }) {
         if (!publicKey)
@@ -169,9 +170,10 @@ export class Account {
     /**
      * Create a meta transaction ready to be signed by a {@link Signer}
      *
-     * @param receiverId NEAR account receiving the transaction
-     * @param actions list of actions to perform as part of the meta transaction
-     * @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
+     * @param options Meta transaction options
+     * @param options.receiverId NEAR account receiving the transaction
+     * @param options.actions list of actions to perform as part of the meta transaction
+     * @param options.blockHeightTtl number of blocks after which a meta transaction will expire if not processed
      */
     async createMetaTransaction({ receiverId, actions, blockHeightTtl = 200, publicKey, }) {
         if (!publicKey)
@@ -197,9 +199,10 @@ export class Account {
     /**
      * Create a signed MetaTransaction that can be broadcasted to a relayer
      *
-     * @param receiverId NEAR account receiving the transaction
-     * @param actions list of actions to perform as part of the meta transaction
-     * @param blockHeightTtl number of blocks after which a meta transaction will expire if not processed
+     * @param options Signed meta transaction options
+     * @param options.receiverId NEAR account receiving the transaction
+     * @param options.actions list of actions to perform as part of the meta transaction
+     * @param options.blockHeightTtl number of blocks after which a meta transaction will expire if not processed
      */
     async createSignedMetaTransaction({ receiverId, actions, blockHeightTtl = 200, signer = this.signer, }) {
         if (!signer)
@@ -215,9 +218,10 @@ export class Account {
     /**
      * Creates a transaction, signs it and broadcast it to the network
      *
-     * @param receiverId The NEAR account ID of the transaction receiver.
-     * @param actions The list of actions to be performed in the transaction.
-     * @param throwOnFailure Whether to throw an error if the transaction fails.
+     * @param options Sign and send transaction options
+     * @param options.receiverId The NEAR account ID of the transaction receiver.
+     * @param options.actions The list of actions to be performed in the transaction.
+     * @param options.throwOnFailure Whether to throw an error if the transaction fails.
      *
      */
     async signAndSendTransaction({ receiverId, actions, waitUntil = DEFAULT_WAIT_STATUS, throwOnFailure = true, signer = this.signer, retries = 10, }) {
@@ -282,9 +286,10 @@ export class Account {
      *    - The new account ID must end with the current account ID
      *    - Example: If your account is `ana.near`, you can create `sub.ana.near`
      *
-     * @param newAccountId the new account to create (e.g. bob.near or sub.ana.near)
-     * @param publicKey the public part of the key that will control the account
-     * @param nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
+     * @param options Account creation options
+     * @param options.newAccountId the new account to create (e.g. bob.near or sub.ana.near)
+     * @param options.publicKey the public part of the key that will control the account
+     * @param options.nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
      *
      */
     async createAccount({ newAccountId, publicKey, nearToTransfer = 0n }) {
@@ -310,9 +315,10 @@ export class Account {
      * Creates a sub account of this account. For example, if the account is
      * ana.near, you can create sub.ana.near.
      *
-     * @param accountOrPrefix a prefix (e.g. `sub`) or the full sub-account (`sub.ana.near`)
-     * @param publicKey the public part of the key that will control the account
-     * @param nearToTransfer how much NEAR to transfer to the account (default: 0)
+     * @param options Sub-account creation options
+     * @param options.accountOrPrefix a prefix (e.g. `sub`) or the full sub-account (`sub.ana.near`)
+     * @param options.publicKey the public part of the key that will control the account
+     * @param options.nearToTransfer how much NEAR to transfer to the account (default: 0)
      *
      */
     async createSubAccount({ accountOrPrefix, publicKey, nearToTransfer = 0n }) {
@@ -421,13 +427,13 @@ export class Account {
     /**
      * Call a function on a smart contract and return parsed transaction result
      *
-     * @param options
-     * @param options.contractId The contract in which to call the function
-     * @param options.methodName The method that will be called
-     * @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
-     * @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
-     * @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
-     * @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
+     * @param params Call function parameters
+     * @param params.contractId The contract in which to call the function
+     * @param params.methodName The method that will be called
+     * @param params.args Arguments, either as a valid JSON Object or a raw Uint8Array
+     * @param params.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
+     * @param params.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
+     * @param params.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
      * @returns
      */
     async callFunction(params) {
@@ -437,13 +443,13 @@ export class Account {
     /**
      * Call a function on a smart contract and return raw transaction outcome
      *
-     * @param options
-     * @param options.contractId The contract in which to call the function
-     * @param options.methodName The method that will be called
-     * @param options.args Arguments, either as a valid JSON Object or a raw Uint8Array
-     * @param options.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
-     * @param options.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
-     * @param options.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
+     * @param params Call function parameters
+     * @param params.contractId The contract in which to call the function
+     * @param params.methodName The method that will be called
+     * @param params.args Arguments, either as a valid JSON Object or a raw Uint8Array
+     * @param params.deposit (optional) Amount of NEAR Tokens to attach to the call (default 0)
+     * @param params.gas (optional) Amount of GAS to use attach to the call (default 30TGas)
+     * @param params.waitUntil (optional) Transaction finality to wait for (default INCLUDED_FINAL)
      */
     async callFunctionRaw({ contractId, methodName, args = {}, deposit = 0n, gas = DEFAULT_FUNCTION_CALL_GAS, waitUntil = DEFAULT_WAIT_STATUS, }) {
         return await this.signAndSendTransaction({
@@ -457,11 +463,11 @@ export class Account {
      *
      * @deprecated This method is deprecated and will be removed in future versions. Please use `signMessage` from `near-api-js/nep413` to sign NEP-413 messages.
      *
-     * @param options
-     * @param options.message The message to be signed (e.g. "authenticating")
-     * @param options.recipient Who will receive the message (e.g. auth.app.com)
-     * @param options.nonce A challenge sent by the recipient
-     * @param options.callbackUrl (optional) Deprecated parameter used only by browser wallets
+     * @param args Nep413 message signing arguments
+     * @param args.message The message to be signed (e.g. "authenticating")
+     * @param args.recipient Who will receive the message (e.g. auth.app.com)
+     * @param args.nonce A challenge sent by the recipient
+     * @param args.callbackUrl (optional) Deprecated parameter used only by browser wallets
      * @returns
      */
     async signNep413Message({ message, recipient, nonce, callbackUrl, }) {
@@ -487,9 +493,10 @@ export class Account {
      *
      * Supports sending either the native NEAR token or any supported Fungible Token (FT).
      *
-     * @param amount - The amount of tokens to transfer in units (e.g. yoctoNEAR).
-     * @param receiverId - The NEAR account ID of the receiver.
-     * @param token - The token to transfer. Defaults to Native NEAR.
+     * @param options Transfer options
+     * @param options.amount - The amount of tokens to transfer in units (e.g. yoctoNEAR).
+     * @param options.receiverId - The NEAR account ID of the receiver.
+     * @param options.token - The token to transfer. Defaults to Native NEAR.
      *
      */
     async transfer({ receiverId, amount, token = NEAR }) {

package/lib/accounts/typed_contract.d.ts

@@ -128,15 +128,9 @@ export type ContractReturnType<abi extends AbiRoot, contractId extends string, _
     abi: abi;
     contractId: contractId;
 }>;
-export declare class Contract<const abi extends AbiRoot, contractId extends string> {
-    abi?: abi;
-    contractId: contractId;
-    view: ContractReturnType<abi, contractId> extends {
-        view: infer ViewMethods;
-    } ? ViewMethods : never;
-    call: ContractReturnType<abi, contractId> extends {
-        call: infer CallMethods;
-    } ? CallMethods : never;
-    constructor({ abi, provider, contractId }: ContractParameters<abi, contractId>);
-}
+export type ContractConstructor = {
+    new <const abi extends AbiRoot, contractId extends string>(params: ContractParameters<abi, contractId>): ContractReturnType<abi, contractId>;
+    new <const abi extends AbiRoot, contractId extends string>(params: Prettify<Omit<ContractParameters<abi, contractId>, 'abi'>>): Prettify<Omit<ContractReturnType<abi, contractId>, 'abi'>>;
+};
+export declare const Contract: ContractConstructor;
 export {};

package/lib/accounts/typed_contract.js

@@ -3,7 +3,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import validator from 'is-my-json-valid';
 import { ArgumentSchemaError, UnknownArgumentError } from './errors.js';
-export class Contract {
+class RawContract {
     constructor({ abi, provider, contractId }) {
         this.contractId = contractId;
         this.abi = abi;
@@ -66,6 +66,7 @@ export class Contract {
         }
     }
 }
+export const Contract = RawContract;
 function validateArguments(args, abiFunction, abiRoot) {
     if (typeof args !== 'object' || typeof abiFunction.params !== 'object')
         return;

package/lib/providers/failover-rpc-provider.d.ts

@@ -1,6 +1,5 @@
 /**
  * @module
- * @description
  * This module contains the {@link FailoverRpcProvider} client class
  * which can be used to interact with multiple [NEAR RPC APIs](https://docs.near.org/api/rpc/introduction).
  * @see {@link "@near-js/types".provider | provider} for a list of request and response types

package/lib/providers/failover-rpc-provider.js

@@ -1,6 +1,5 @@
 /**
  * @module
- * @description
  * This module contains the {@link FailoverRpcProvider} client class
  * which can be used to interact with multiple [NEAR RPC APIs](https://docs.near.org/api/rpc/introduction).
  * @see {@link "@near-js/types".provider | provider} for a list of request and response types

package/lib/providers/json-rpc-provider.d.ts

@@ -1,6 +1,5 @@
 /**
  * @module
- * @description
  * This module contains the {@link JsonRpcProvider} client class
  * which can be used to interact with the [NEAR RPC API](https://docs.near.org/api/rpc/introduction).
  * @see {@link "@near-js/types".provider | provider} for a list of request and response types

package/lib/providers/json-rpc-provider.js

@@ -1,6 +1,5 @@
 /**
  * @module
- * @description
  * This module contains the {@link JsonRpcProvider} client class
  * which can be used to interact with the [NEAR RPC API](https://docs.near.org/api/rpc/introduction).
  * @see {@link "@near-js/types".provider | provider} for a list of request and response types

package/lib/rpc/types.gen.d.ts

@@ -128,9 +128,9 @@ export type AccountDataView = {
  *
  * This is a unique, syntactically valid, human-readable account identifier on the NEAR network.
  *
- * [See the crate-level docs for information about validation.](index.html#account-id-rules)
+ * [See the Rust crate documentation for information about validation.](https://docs.rs/near-account-id/latest/near_account_id/)
  *
- * Also see [Error kind precedence](AccountId#error-kind-precedence).
+ * Also see the error kind documentation.
  *
  * ## Examples
  *
@@ -4411,10 +4411,9 @@ export type RpcStateChangesError = {
 /**
  * RpcStateChangesInBlockByTypeRequest
  *
- * It is a [serializable view] of [`StateChangesRequest`].
+ * It is a serializable view of `StateChangesRequest`.
  *
- * [serializable view]: ./index.html
- * [`StateChangesRequest`]: ../types/struct.StateChangesRequest.html
+ * See the Rust crate documentation for more information.
  */
 export type RpcStateChangesInBlockByTypeRequest = ({
     block_id: BlockId;
@@ -5315,10 +5314,9 @@ export type StateChangeCauseView = {
     type: 'bandwidth_scheduler_state_update';
 };
 /**
- * It is a [serializable view] of [`StateChangeKind`].
+ * It is a serializable view of `StateChangeKind`.
  *
- * [serializable view]: ./index.html
- * [`StateChangeKind`]: ../types/struct.StateChangeKind.html
+ * See the Rust crate documentation for more information.
  */
 export type StateChangeKindView = {
     account_id: AccountId;

package/lib/tokens/ft/index.d.ts

@@ -19,7 +19,7 @@ declare abstract class BaseFT {
     /**
      * Converts indivisible units to a decimal number (represented as a string)
      *
-     * @param units The amount in indivisible units (e.g. "1234")
+     * @param amount The amount in indivisible units (e.g. "1234")
      * @param precision (optional) number of digits shown to the right of the decimal point - rounded down
      * @returns The amount as a decimal string (e.g. "1.234")
      */
@@ -66,10 +66,10 @@ export declare class FungibleToken extends BaseFT {
      * Transfer tokens and call a function on the receiver contract,
      * only works if the receiver implements the `ft_on_transfer` method
      *
-     * @param param
+     * @param param Transfer call parameters
      * @param param.from The Account that will transfer the tokens
      * @param param.receiverId The AccountID that will receive the tokens
-     * @param param.units The amount of tokens to transfer in the smallest unit
+     * @param param.amount The amount of tokens to transfer in the smallest unit
      * @param param.msg The message to send to the `ft_on_transfer` method
      */
     transferCall({ from, receiverId, amount, msg, }: {

package/lib/tokens/ft/index.js

@@ -17,7 +17,7 @@ class BaseFT {
     /**
      * Converts indivisible units to a decimal number (represented as a string)
      *
-     * @param units The amount in indivisible units (e.g. "1234")
+     * @param amount The amount in indivisible units (e.g. "1234")
      * @param precision (optional) number of digits shown to the right of the decimal point - rounded down
      * @returns The amount as a decimal string (e.g. "1.234")
      */
@@ -67,10 +67,10 @@ export class FungibleToken extends BaseFT {
      * Transfer tokens and call a function on the receiver contract,
      * only works if the receiver implements the `ft_on_transfer` method
      *
-     * @param param
+     * @param param Transfer call parameters
      * @param param.from The Account that will transfer the tokens
      * @param param.receiverId The AccountID that will receive the tokens
-     * @param param.units The amount of tokens to transfer in the smallest unit
+     * @param param.amount The amount of tokens to transfer in the smallest unit
      * @param param.msg The message to send to the `ft_on_transfer` method
      */
     async transferCall({ from, receiverId, amount, msg, }) {

package/lib/transactions/action_creators.d.ts

@@ -84,8 +84,9 @@ declare function deleteKey(publicKey: PublicKey): Action;
 declare function deleteAccount(beneficiaryId: string): Action;
 /**
  * Creates a new action for a signed delegation, specifying the delegate action and signature.
- * @param delegateAction The delegate action to be performed.
- * @param signature The signature associated with the delegate action.
+ * @param options Signed delegate options
+ * @param options.delegateAction The delegate action to be performed.
+ * @param options.signature The signature associated with the delegate action.
  * @returns A new action for a signed delegation.
  */
 declare function signedDelegate({ delegateAction, signature, }: {
@@ -98,13 +99,13 @@ declare function signedDelegate({ delegateAction, signature, }: {
  * @param deployMode The mode to deploy global contract (CodeHash or AccountId).
  * @returns A new action for deploying a global contract.
  */
-declare function deployGlobalContract(code: Uint8Array, mode: 'codeHash' | 'accountId'): Action;
+declare function deployGlobalContract(code: Uint8Array, deployMode: 'codeHash' | 'accountId'): Action;
 /**
  * Creates a new action for using a previously deployed global contract.
  * @param contractIdentifier The global contract identifier (hash or account id).
  * @returns A new action for using a global contract.
  */
-declare function useGlobalContract(identifier: {
+declare function useGlobalContract(contractIdentifier: {
     accountId: string;
 } | {
     codeHash: string | Uint8Array;

package/lib/transactions/action_creators.js

@@ -136,8 +136,9 @@ function deleteAccount(beneficiaryId) {
 }
 /**
  * Creates a new action for a signed delegation, specifying the delegate action and signature.
- * @param delegateAction The delegate action to be performed.
- * @param signature The signature associated with the delegate action.
+ * @param options Signed delegate options
+ * @param options.delegateAction The delegate action to be performed.
+ * @param options.signature The signature associated with the delegate action.
  * @returns A new action for a signed delegation.
  */
 function signedDelegate({ delegateAction, signature, }) {
@@ -151,28 +152,28 @@ function signedDelegate({ delegateAction, signature, }) {
  * @param deployMode The mode to deploy global contract (CodeHash or AccountId).
  * @returns A new action for deploying a global contract.
  */
-function deployGlobalContract(code, mode) {
-    const deployMode = mode === 'codeHash'
+function deployGlobalContract(code, deployMode) {
+    const mode = deployMode === 'codeHash'
         ? new GlobalContractDeployMode({ CodeHash: null })
         : new GlobalContractDeployMode({ AccountId: null });
-    return new Action({ deployGlobalContract: new DeployGlobalContract({ code, deployMode }) });
+    return new Action({ deployGlobalContract: new DeployGlobalContract({ code, deployMode: mode }) });
 }
 /**
  * Creates a new action for using a previously deployed global contract.
  * @param contractIdentifier The global contract identifier (hash or account id).
  * @returns A new action for using a global contract.
  */
-function useGlobalContract(identifier) {
-    const contractIdentifier = 'accountId' in identifier
+function useGlobalContract(contractIdentifier) {
+    const identifier = 'accountId' in contractIdentifier
         ? new GlobalContractIdentifier({
-            AccountId: identifier.accountId,
+            AccountId: contractIdentifier.accountId,
         })
         : new GlobalContractIdentifier({
-            CodeHash: typeof identifier.codeHash === 'string'
-                ? Buffer.from(identifier.codeHash, 'hex')
-                : identifier.codeHash,
+            CodeHash: typeof contractIdentifier.codeHash === 'string'
+                ? Buffer.from(contractIdentifier.codeHash, 'hex')
+                : contractIdentifier.codeHash,
         });
-    return new Action({ useGlobalContract: new UseGlobalContract({ contractIdentifier }) });
+    return new Action({ useGlobalContract: new UseGlobalContract({ contractIdentifier: identifier }) });
 }
 export const actions = {
     addFullAccessKey,

package/lib/transactions/delegate.d.ts

@@ -18,11 +18,12 @@ export declare class DelegateAction {
 }
 /**
  * Compose a delegate action for inclusion with a meta transaction signed on the sender's behalf
- * @param actions The set of actions to be included in the meta transaction
- * @param maxBlockHeight The maximum block height for which this action can be executed as part of a transaction
- * @param nonce Current nonce on the access key used to sign the delegate action
- * @param publicKey Public key for the access key used to sign the delegate action
- * @param receiverId Account ID for the intended receiver of the meta transaction
- * @param senderId Account ID for the intended signer of the delegate action
+ * @param options Delegate action options
+ * @param options.actions The set of actions to be included in the meta transaction
+ * @param options.maxBlockHeight The maximum block height for which this action can be executed as part of a transaction
+ * @param options.nonce Current nonce on the access key used to sign the delegate action
+ * @param options.publicKey Public key for the access key used to sign the delegate action
+ * @param options.receiverId Account ID for the intended receiver of the meta transaction
+ * @param options.senderId Account ID for the intended signer of the delegate action
  */
 export declare function buildDelegateAction({ actions, maxBlockHeight, nonce, publicKey, receiverId, senderId, }: DelegateAction): DelegateAction;

package/lib/transactions/delegate.js

@@ -13,12 +13,13 @@ export class DelegateAction {
 }
 /**
  * Compose a delegate action for inclusion with a meta transaction signed on the sender's behalf
- * @param actions The set of actions to be included in the meta transaction
- * @param maxBlockHeight The maximum block height for which this action can be executed as part of a transaction
- * @param nonce Current nonce on the access key used to sign the delegate action
- * @param publicKey Public key for the access key used to sign the delegate action
- * @param receiverId Account ID for the intended receiver of the meta transaction
- * @param senderId Account ID for the intended signer of the delegate action
+ * @param options Delegate action options
+ * @param options.actions The set of actions to be included in the meta transaction
+ * @param options.maxBlockHeight The maximum block height for which this action can be executed as part of a transaction
+ * @param options.nonce Current nonce on the access key used to sign the delegate action
+ * @param options.publicKey Public key for the access key used to sign the delegate action
+ * @param options.receiverId Account ID for the intended receiver of the meta transaction
+ * @param options.senderId Account ID for the intended signer of the delegate action
  */
 export function buildDelegateAction({ actions, maxBlockHeight, nonce, publicKey, receiverId, senderId, }) {
     return new DelegateAction({

package/lib/utils/format.d.ts

@@ -8,7 +8,7 @@ export declare const NEAR_NOMINATION_EXP = 24;
  */
 export declare const NEAR_NOMINATION: bigint;
 /**
- * @deprecated use {@link yoctoToNear} instead.
+ * @deprecated use {@link units!yoctoToNear} from 'near-api-js' instead.
  *
  * Convert account balance value from internal indivisible units to NEAR. 1 NEAR is defined by {@link NEAR_NOMINATION}.
  * Effectively this divides given amount by {@link NEAR_NOMINATION}.
@@ -19,12 +19,12 @@ export declare const NEAR_NOMINATION: bigint;
  */
 export declare function formatNearAmount(balance: string | number | bigint, fracDigits?: number): string;
 /**
- * @deprecated use {@link nearToYocto} instead.
+ * @deprecated use {@link units!nearToYocto} from 'near-api-js' instead.
  *
  * Convert human readable NEAR amount to internal indivisible units.
  * Effectively this multiplies given amount by {@link NEAR_NOMINATION}.
  *
- * @param amt decimal string (potentially fractional) denominated in NEAR.
+ * @param amount decimal string (potentially fractional) denominated in NEAR.
  * @returns The parsed yoctoⓃ amount
  * @throws {Error} if the amount is empty or invalid
  */

package/lib/utils/format.js

@@ -14,7 +14,7 @@ for (let i = 0, offset = 5n; i < NEAR_NOMINATION_EXP; i++, offset = offset * BN1
     ROUNDING_OFFSETS[i] = offset;
 }
 /**
- * @deprecated use {@link yoctoToNear} instead.
+ * @deprecated use {@link units!yoctoToNear} from 'near-api-js' instead.
  *
  * Convert account balance value from internal indivisible units to NEAR. 1 NEAR is defined by {@link NEAR_NOMINATION}.
  * Effectively this divides given amount by {@link NEAR_NOMINATION}.
@@ -41,12 +41,12 @@ export function formatNearAmount(balance, fracDigits = NEAR_NOMINATION_EXP) {
     return trimTrailingZeroes(`${formatWithCommas(wholeStr)}.${fractionStr}`);
 }
 /**
- * @deprecated use {@link nearToYocto} instead.
+ * @deprecated use {@link units!nearToYocto} from 'near-api-js' instead.
  *
  * Convert human readable NEAR amount to internal indivisible units.
  * Effectively this multiplies given amount by {@link NEAR_NOMINATION}.
  *
- * @param amt decimal string (potentially fractional) denominated in NEAR.
+ * @param amount decimal string (potentially fractional) denominated in NEAR.
  * @returns The parsed yoctoⓃ amount
  * @throws {Error} if the amount is empty or invalid
  */

package/lib/utils/validators.d.ts

@@ -1,10 +1,10 @@
 import type { CurrentEpochValidatorInfo, NextEpochValidatorInfo } from '../types/index.js';
 /** Finds seat price given validators stakes and number of seats.
  *  Calculation follow the spec: https://nomicon.io/Economics/README.html#validator-selection
- * @param validators: current or next epoch validators.
- * @param maxNumberOfSeats: maximum number of seats in the network.
- * @param minimumStakeRatio: minimum stake ratio
- * @param protocolVersion: version of the protocol from genesis config
+ * @param validators current or next epoch validators.
+ * @param maxNumberOfSeats maximum number of seats in the network.
+ * @param minimumStakeRatio minimum stake ratio
+ * @param protocolVersion version of the protocol from genesis config
  */
 export declare function findSeatPrice(validators: (CurrentEpochValidatorInfo | NextEpochValidatorInfo)[], maxNumberOfSeats: number, minimumStakeRatio: number[], protocolVersion?: number): bigint;
 export interface ChangedValidatorInfo {
@@ -18,7 +18,7 @@ export interface EpochValidatorsDiff {
 }
 /** Diff validators between current and next epoch.
  * Returns additions, subtractions and changes to validator set.
- * @param currentValidators: list of current validators.
- * @param nextValidators: list of next validators.
+ * @param currentValidators list of current validators.
+ * @param nextValidators list of next validators.
  */
 export declare function diffEpochValidators(currentValidators: CurrentEpochValidatorInfo[], nextValidators: NextEpochValidatorInfo[]): EpochValidatorsDiff;

package/lib/utils/validators.js

@@ -1,10 +1,10 @@
 import { sortBigIntAsc } from './utils.js';
 /** Finds seat price given validators stakes and number of seats.
  *  Calculation follow the spec: https://nomicon.io/Economics/README.html#validator-selection
- * @param validators: current or next epoch validators.
- * @param maxNumberOfSeats: maximum number of seats in the network.
- * @param minimumStakeRatio: minimum stake ratio
- * @param protocolVersion: version of the protocol from genesis config
+ * @param validators current or next epoch validators.
+ * @param maxNumberOfSeats maximum number of seats in the network.
+ * @param minimumStakeRatio minimum stake ratio
+ * @param protocolVersion version of the protocol from genesis config
  */
 export function findSeatPrice(validators, maxNumberOfSeats, minimumStakeRatio, protocolVersion) {
     if (protocolVersion && protocolVersion < 49) {
@@ -63,8 +63,8 @@ function findSeatPriceForProtocolAfter49(validators, maxNumberOfSeats, minimumSt
 }
 /** Diff validators between current and next epoch.
  * Returns additions, subtractions and changes to validator set.
- * @param currentValidators: list of current validators.
- * @param nextValidators: list of next validators.
+ * @param currentValidators list of current validators.
+ * @param nextValidators list of next validators.
  */
 export function diffEpochValidators(currentValidators, nextValidators) {
     const validatorsMap = new Map();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "near-api-js",
   "description": "JavaScript library to interact with NEAR Protocol via RPC API",
-  "version": "7.0.2",
+  "version": "7.0.4",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/near/near-api-js.git"
@@ -85,12 +85,12 @@
     "near-sandbox": "0.0.18"
   },
   "scripts": {
-    "compile": "tsc -p ./tsconfig.json",
+    "compile": "tsc -p ./tsconfig.build.json",
     "dev": "pnpm compile -w",
     "prebuild": "pnpm clean",
-    "build": "tsc -p ./tsconfig.json",
+    "build": "tsc -p ./tsconfig.build.json",
     "test": "vitest run test",
-    "typecheck": "tsc --noEmit -p ./tsconfig.typecheck.json",
+    "typecheck": "tsc --noEmit -p ./tsconfig.json",
     "lint": "biome check",
     "prefuzz": "pnpm build",
     "fuzz": "jsfuzz test/fuzz/borsh-roundtrip.js test/fuzz/corpus/",