near-api-js

To increase throughput and avoid nonce collisions, you can send transactions in parallel by rotating multiple keys for a single account.

1. Generate multiple KeyPairs.
2. Add these keys to the NEAR account using actions.addFullAccessKey.
3. Use MultiKeySigner to wrap the keys.
4. Initialize an Account with the MultiKeySigner instead of a single private key.

near-api-js automatically handles nonce collisions by retrying with an incremented nonce.

import { Account, actions, JsonRpcProvider, KeyPair, MultiKeySigner } from "near-api-js"
import { NEAR } from "near-api-js/tokens"

const provider = new JsonRpcProvider({
  url: "https://test.rpc.fastnear.com",
})

const accountId = '...';
const account = new Account(accountId, provider, privateKey)

// create 10 keys and add them to the account
const keys = []
const txActions = []
for (let j = 0; j < 10; j++) {
  const newKeyPair = KeyPair.fromRandom('ed25519')
  keys.push(newKeyPair)
  txActions.push(
    actions.addFullAccessKey(newKeyPair.getPublicKey())
  )
}

await account.signAndSendTransaction({
  receiverId: accountId,
  actions: txActions
})

// ------- Send NEAR tokens using multiple keys -------
const multiKeySigner = new MultiKeySigner(keys)
const multiAccount = new Account(accountId, provider, multiKeySigner)

const transfers = []
for (let i = 0; i < 100; i++) {
  transfers.push(
    multiAccount.transfer({
        token: NEAR,
        amount: NEAR.toUnits("0.001"),
        receiverId: "influencer.testnet"
      })
    ))
}

const sendNearTokensResults = await Promise.all(transfers)

For scenarios like offline signing, you can separate the process of building, signing, and sending a transaction.

1. Build: Use account.createTransaction with only the accountId and publicKey to create a transaction object.
2. Sign: Use KeyPairSigner.fromSecretKey to sign the transaction with a private key.
3. Send: Use provider.sendTransaction to broadcast the signed transaction to the network.

import { JsonRpcProvider, Account, KeyPairSigner, actions, nearToYocto, KeyPairString } from "near-api-js";

const provider = new JsonRpcProvider({
  url: "https://test.rpc.fastnear.com",
});

const publicKey = '';
const accountId = '';
const account = new Account(accountId, provider);

// 1. Create transaction
const transaction = await account.createTransaction({
  receiverId: "receiver-account.testnet",
  actions: [actions.transfer(nearToYocto("0.1"))],
  publicKey: publicKey
});

// 2. Sign transaction (offline/separately)
const signer = KeyPairSigner.fromSecretKey(privateKey as KeyPairString);
const signResult = await signer.signTransaction(transaction);

// 3. Send transaction
const sendTransactionResult = await provider.sendTransaction(signResult.signedTransaction);
console.log(sendTransactionResult);

To interact with the NEAR blockchain, you need a JsonRpcProvider to connect to an RPC endpoint.

• Read-only calls: Use provider.callFunction directly. This does not require a private key.
• State-modifying calls: Use the Account class. You must provide an accountId, the provider, and a privateKey (as a KeyPairString) to sign transactions.

import { Account, JsonRpcProvider, teraToGas, KeyPairString, nearToYocto } from "near-api-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'),
});

The MultiKeySigner is designed for high-throughput scenarios where you need to sign multiple transactions in parallel. By rotating through a set of provided keys, it helps avoid nonce conflicts that occur when multiple transactions are sent from the same key simultaneously.

When calling getPublicKey(), the signer rotates to the next key in the array. When signing transactions or delegate actions, it automatically selects the key that matches the public key specified in the transaction/action, ensuring the correct key is used for the specific operation.

const signer = new MultiKeySigner([key1, key2, key3]);
const account = new Account('account.near', provider, signer);

// These will use different keys in rotation to enable parallel execution
await Promise.all([
  account.transfer({ receiverId: 'bob.near', amount: 1n }),
  account.transfer({ receiverId: 'alice.near', amount: 2n }),
  account.transfer({ receiverId: 'carol.near', amount: 3n }),
]);

When querying the results of a transaction or receipt, the ExecutionOutcomeView provides a detailed summary of the execution.

Key fields include:

• executor_id: The account ID where execution occurred (signer for transactions, receiver for receipts).
• gas_burnt: The amount of gas consumed.
• logs: An array of strings containing execution logs.
• status: An ExecutionStatusView indicating if the execution was a SuccessValue, SuccessReceiptId, a Failure (with TxExecutionError), or Unknown.
• tokens_burnt: The amount of tokens consumed (may differ from gas_burnt due to gas price differences).
• receipt_ids: IDs of any receipts generated by this execution.

// Example structure of an ExecutionOutcomeView
const outcome: ExecutionOutcomeView = {
  executor_id: 'user.near',
  gas_burnt: '1000000000000000000',
  logs: ['Hello from NEAR!'],
  status: { SuccessValue: '42' },
  receipt_ids: ['...hash...'],
  tokens_burnt: '1000000000000000000'
};