near-api-js 7.0.0-rc.1 → 7.0.0-rc.3

package/lib/accounts/account.d.ts

@@ -1,10 +1,10 @@
 import { type KeyPairString, PublicKey } from '../crypto/index.js';
-import type { Provider } from '../providers/index.js';
+import { type Provider } from '../providers/index.js';
 import { type SignedMessage, type Signer } from '../signers/index.js';
 import type { SignDelegateActionReturn } from '../signers/signer.js';
 import type { FungibleToken, NativeToken } from '../tokens/index.js';
 import { type Action, type DelegateAction, type SignedTransaction } from '../transactions/index.js';
-import type { AccessKeyList, AccessKeyView, ContractCodeView, ContractStateView, FinalExecutionOutcome, SerializedReturnValue, TxExecutionStatus } from '../types/index.js';
+import type { FinalExecutionOutcome, SerializedReturnValue, TxExecutionStatus } from '../types/index.js';
 export declare const DEFAULT_WAIT_STATUS: TxExecutionStatus;
 export interface AccountState {
     balance: {
@@ -44,6 +44,7 @@ export interface SignAndSendTransactionArgs {
     waitUntil?: TxExecutionStatus;
     throwOnFailure?: boolean;
     signer?: Signer;
+    retries?: number;
 }
 export interface SignAndSendTransactionsArgs {
     transactions: Array<{
@@ -99,7 +100,8 @@ export declare class Account {
     readonly accountId: string;
     readonly provider: Provider;
     private signer?;
-    constructor(accountId: string, provider: Provider, signer?: Signer | KeyPairString);
+    private readonly nonceManager;
+    constructor(accountId: string, provider: Provider | string, signer?: Signer | KeyPairString);
     /**
      * Allows to set the signer used to control the account
      *
@@ -116,21 +118,27 @@ export declare class Account {
      * Calls {@link Provider.viewAccessKey} to retrieve information for a
      * specific key in the account
      */
-    getAccessKey(publicKey: PublicKey | string): Promise<AccessKeyView>;
+    getAccessKey(publicKey: PublicKey | string): Promise<import("../types/index.js").AccessKeyView>;
     /**
      * Calls {@link Provider.viewAccessKeyList} to retrieve the account's keys
      */
-    getAccessKeyList(): Promise<AccessKeyList>;
+    getAccessKeyList(): Promise<import("../rpc/types.gen.js").AccessKeyList & {
+        block_hash: import("../rpc/types.gen.js").CryptoHash;
+        block_height: number;
+    }>;
     /**
      * Calls {@link Provider.viewContractCode} to retrieve the account's
      * contract code and its hash
      */
-    getContractCode(): Promise<ContractCodeView>;
+    getContractCode(): Promise<import("../types/index.js").ContractCodeView>;
     /**
      * Calls {@link Provider.viewContractState} to retrieve the keys and values
      * stored on the account's contract
      */
-    getContractState(prefix?: string): Promise<ContractStateView>;
+    getContractState(prefix?: string): Promise<import("../rpc/types.gen.js").ViewStateResult & {
+        block_hash: import("../rpc/types.gen.js").CryptoHash;
+        block_height: number;
+    }>;
     /**
      * Create a transaction that can be later signed with a {@link Signer}
      *
@@ -168,8 +176,8 @@ export declare class Account {
      * @returns {Promise<FinalExecutionOutcome>} A promise that resolves to the final execution outcome of the transaction.
      *
      */
-    signAndSendTransaction({ receiverId, actions, waitUntil, throwOnFailure, signer, }: SignAndSendTransactionArgs): Promise<FinalExecutionOutcome>;
-    signAndSendTransactions({ transactions, waitUntil, throwOnFailure, signer, }: SignAndSendTransactionsArgs): Promise<FinalExecutionOutcome[]>;
+    signAndSendTransaction({ receiverId, actions, waitUntil, throwOnFailure, signer, retries, }: SignAndSendTransactionArgs): any;
+    signAndSendTransactions({ transactions, waitUntil, throwOnFailure, signer, }: SignAndSendTransactionsArgs): Promise<any[]>;
     /**
      * Creates a new NEAR account with a given ID and public key.
      *
@@ -186,7 +194,7 @@ export declare class Account {
      * @param nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
      *
      */
-    createAccount({ newAccountId, publicKey, nearToTransfer, }: CreateAccountArgs): Promise<FinalExecutionOutcome>;
+    createAccount({ newAccountId, publicKey, nearToTransfer }: CreateAccountArgs): Promise<any>;
     /**
      * Creates a sub account of this account. For example, if the account is
      * ana.near, you can create sub.ana.near.
@@ -196,7 +204,7 @@ export declare class Account {
      * @param nearToTransfer how much NEAR to transfer to the account (default: 0)
      *
      */
-    createSubAccount({ accountOrPrefix, publicKey, nearToTransfer, }: CreateSubAccountArgs): Promise<FinalExecutionOutcome>;
+    createSubAccount({ accountOrPrefix, publicKey, nearToTransfer }: CreateSubAccountArgs): Promise<any>;
     /**
      * Deletes the account, transferring all remaining NEAR to a beneficiary
      * account
@@ -205,20 +213,20 @@ export declare class Account {
      *
      * @param beneficiaryId Will receive the account's remaining balance
      */
-    deleteAccount(beneficiaryId: string): Promise<FinalExecutionOutcome>;
+    deleteAccount(beneficiaryId: string): Promise<any>;
     /**
      * Deploy a smart contract in the account
      *
      * @param code The compiled contract code bytes
      */
-    deployContract(code: Uint8Array): Promise<FinalExecutionOutcome>;
+    deployContract(code: Uint8Array): Promise<any>;
     /**
      * Deploy a global contract that can be reused by multiple accounts
      *
      * @param code The compiled contract code bytes
      * @param deployMode Deploy mode - "codeHash" for immutable contracts, "accountId" for updateable contracts
      */
-    deployGlobalContract(code: Uint8Array, deployMode: 'codeHash' | 'accountId'): Promise<FinalExecutionOutcome>;
+    deployGlobalContract(code: Uint8Array, deployMode: 'codeHash' | 'accountId'): Promise<any>;
     /**
      * Use a previously deployed global contract on this account
      *
@@ -228,7 +236,7 @@ export declare class Account {
         accountId: string;
     } | {
         codeHash: string | Uint8Array;
-    }): Promise<FinalExecutionOutcome>;
+    }): Promise<any>;
     /**
      *
      * @param options
@@ -238,19 +246,17 @@ export declare class Account {
      * @param options.allowance The amount of NEAR this key can expend in gas
      * @returns
      */
-    addFunctionCallAccessKey({ publicKey, contractId, methodNames, allowance, }: AddFunctionAccessKeyArgs): Promise<FinalExecutionOutcome>;
+    addFunctionCallAccessKey({ publicKey, contractId, methodNames, allowance, }: AddFunctionAccessKeyArgs): Promise<any>;
     /**
      * Add a full access key to the account
      *
      * @param publicKey The public key to be added
-     * @returns {Promise<FinalExecutionOutcome>}
      */
-    addFullAccessKey(publicKey: PublicKey | string): Promise<FinalExecutionOutcome>;
+    addFullAccessKey(publicKey: PublicKey | string): Promise<any>;
     /**
      * @param publicKey The public key to be deleted
-     * @returns {Promise<FinalExecutionOutcome>}
      */
-    deleteKey(publicKey: PublicKey | string): Promise<FinalExecutionOutcome>;
+    deleteKey(publicKey: PublicKey | string): Promise<any>;
     /**
      * Call a function on a smart contract and return parsed transaction result
      *
@@ -274,9 +280,8 @@ export declare class Account {
      * @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)
-     * @returns {FinalExecutionOutcome}
      */
-    callFunctionRaw({ contractId, methodName, args, deposit, gas, waitUntil, }: CallFunctionArgs): Promise<FinalExecutionOutcome>;
+    callFunctionRaw({ contractId, methodName, args, deposit, gas, waitUntil, }: CallFunctionArgs): Promise<any>;
     /**
      * This function simply calls the `signNep413Message` method of the Signer
      *

package/lib/accounts/account.js

@@ -1,8 +1,12 @@
 import { PublicKey } from '../crypto/index.js';
+import { parseTransactionExecutionError } from '../providers/errors/parse.js';
+import { InvalidNonceError } from '../providers/errors/transaction_execution.js';
+import { JsonRpcProvider } from '../providers/index.js';
 import { KeyPairSigner } from '../signers/index.js';
 import { NEAR } from '../tokens/index.js';
 import { actionCreators, buildDelegateAction, createTransaction, GlobalContractDeployMode, GlobalContractIdentifier, } from '../transactions/index.js';
-import { baseDecode, getTransactionLastResult, parseResultError } from '../utils/index.js';
+import { baseDecode, getTransactionLastResult } from '../utils/index.js';
+import { NonceManager } from './nonce-manager.js';
 const { addKey, createAccount, deleteAccount, deleteKey, deployContract, deployGlobalContract, fullAccessKey, functionCall, functionCallAccessKey, transfer, useGlobalContract, } = actionCreators;
 const DEFAULT_FINALITY = 'optimistic';
 export const DEFAULT_WAIT_STATUS = 'EXECUTED_OPTIMISTIC';
@@ -16,13 +20,19 @@ const DEFAULT_FUNCTION_CALL_GAS = 30000000000000n; // 30 TGas
 export class Account {
     constructor(accountId, provider, signer) {
         this.accountId = accountId;
-        this.provider = provider;
+        if (typeof provider === 'string') {
+            this.provider = new JsonRpcProvider({ url: provider });
+        }
+        else {
+            this.provider = provider;
+        }
         if (typeof signer === 'string') {
             this.signer = KeyPairSigner.fromSecretKey(signer);
         }
         else {
             this.signer = signer;
         }
+        this.nonceManager = new NonceManager();
     }
     /**
      * Allows to set the signer used to control the account
@@ -51,6 +61,10 @@ export class Account {
                 },
             }),
         ]);
+        if (typeof protocolConfig.runtime_config !== 'object' || protocolConfig.runtime_config === null)
+            throw new Error('runtime_config is not defined in protocol config');
+        if (typeof protocolConfig.runtime_config.storage_amount_per_byte === 'undefined')
+            throw new Error('runtime_config.storage_amount_per_byte is not defined in protocol config');
         const costPerByte = BigInt(protocolConfig.runtime_config.storage_amount_per_byte);
         const usedOnStorage = BigInt(state.storage_usage) * costPerByte;
         const locked = BigInt(state.locked);
@@ -127,15 +141,14 @@ export class Account {
         if (!publicKey)
             throw new Error('Please provide a public key');
         const pk = PublicKey.from(publicKey);
-        const [accessKey, block] = await Promise.all([
-            this.getAccessKey(pk),
+        const [nonce, block] = await Promise.all([
+            this.nonceManager.resolveNextNonce(pk, this.accountId, this.provider),
             this.provider.viewBlock({
                 finality: DEFAULT_FINALITY,
             }),
         ]);
         const recentBlockHash = block.header.hash;
-        const nonce = BigInt(accessKey.nonce) + 1n;
-        return createTransaction(this.accountId, pk, receiverId, nonce + 1n, actions, baseDecode(recentBlockHash));
+        return createTransaction(this.accountId, pk, receiverId, nonce, actions, baseDecode(recentBlockHash));
     }
     /**
      * Create a signed transaction ready to be broadcast by a {@link Provider}
@@ -206,18 +219,40 @@ export class Account {
      * @returns {Promise<FinalExecutionOutcome>} A promise that resolves to the final execution outcome of the transaction.
      *
      */
-    async signAndSendTransaction({ receiverId, actions, waitUntil = DEFAULT_WAIT_STATUS, throwOnFailure = true, signer = this.signer, }) {
+    async signAndSendTransaction({ receiverId, actions, waitUntil = DEFAULT_WAIT_STATUS, throwOnFailure = true, signer = this.signer, retries = 3, }) {
         const signedTx = await this.createSignedTransaction({
             receiverId,
             actions,
             signer,
         });
-        const result = await this.provider.sendTransactionUntil(signedTx, waitUntil);
+        let result;
+        try {
+            result = await this.provider.sendTransactionUntil(signedTx, waitUntil);
+        }
+        catch (error) {
+            if (error instanceof InvalidNonceError) {
+                // invalidate nonce cache so we don't send another transaction with stale nonce
+                await this.nonceManager.invalidate(signedTx.transaction.publicKey);
+                if (retries > 0) {
+                    return this.signAndSendTransaction({
+                        receiverId,
+                        actions,
+                        waitUntil,
+                        throwOnFailure,
+                        signer,
+                        retries: retries - 1,
+                    });
+                }
+            }
+            throw error;
+        }
         if (throwOnFailure &&
             typeof result.status === 'object' &&
+            result.status !== null &&
+            'Failure' in result.status &&
             typeof result.status.Failure === 'object' &&
             result.status.Failure !== null) {
-            throw parseResultError(result);
+            throw parseTransactionExecutionError(result.status.Failure, result.transaction_outcome.id, result.transaction_outcome.block_hash);
         }
         return result;
     }
@@ -251,7 +286,7 @@ export class Account {
      * @param nearToTransfer how much NEAR to transfer to the account in yoctoNEAR (default: 0)
      *
      */
-    async createAccount({ newAccountId, publicKey, nearToTransfer = 0n, }) {
+    async createAccount({ newAccountId, publicKey, nearToTransfer = 0n }) {
         if (newAccountId.endsWith(this.accountId)) {
             return this.createSubAccount({ accountOrPrefix: newAccountId, publicKey, nearToTransfer });
         }
@@ -279,7 +314,7 @@ export class Account {
      * @param nearToTransfer how much NEAR to transfer to the account (default: 0)
      *
      */
-    async createSubAccount({ accountOrPrefix, publicKey, nearToTransfer = 0n, }) {
+    async createSubAccount({ accountOrPrefix, publicKey, nearToTransfer = 0n }) {
         if (!this.signer)
             throw new Error('Please set a signer');
         const newAccountId = accountOrPrefix.includes('.') ? accountOrPrefix : `${accountOrPrefix}.${this.accountId}`;
@@ -380,7 +415,6 @@ export class Account {
      * Add a full access key to the account
      *
      * @param publicKey The public key to be added
-     * @returns {Promise<FinalExecutionOutcome>}
      */
     async addFullAccessKey(publicKey) {
         return this.signAndSendTransaction({
@@ -390,7 +424,6 @@ export class Account {
     }
     /**
      * @param publicKey The public key to be deleted
-     * @returns {Promise<FinalExecutionOutcome>}
      */
     async deleteKey(publicKey) {
         return this.signAndSendTransaction({
@@ -424,7 +457,6 @@ export class Account {
      * @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)
-     * @returns {FinalExecutionOutcome}
      */
     async callFunctionRaw({ contractId, methodName, args = {}, deposit = 0n, gas = DEFAULT_FUNCTION_CALL_GAS, waitUntil = DEFAULT_WAIT_STATUS, }) {
         return await this.signAndSendTransaction({

package/lib/accounts/nonce-manager.d.ts

@@ -0,0 +1,9 @@
+import type { PublicKey } from '../crypto/public_key.js';
+import type { Provider } from '../providers/provider.js';
+export declare class NonceManager {
+    private nonces;
+    private locks;
+    constructor();
+    resolveNextNonce(pk: PublicKey, accountId: string, provider: Provider): Promise<bigint>;
+    invalidate(pk: PublicKey): Promise<void>;
+}

package/lib/accounts/nonce-manager.js

@@ -0,0 +1,43 @@
+export class NonceManager {
+    constructor() {
+        this.nonces = {};
+        this.locks = {};
+    }
+    async resolveNextNonce(pk, accountId, provider) {
+        const key = pk.toString();
+        // wait until unlocked
+        const lock = this.locks[key];
+        if (lock)
+            await lock;
+        if (typeof this.nonces[key] === 'bigint') {
+            this.nonces[key] = this.nonces[key] + 1n;
+            return this.nonces[key];
+        }
+        // biome-ignore lint/suspicious/noEmptyBlockStatements: unlock is immediately overwritten
+        let unlock = () => { };
+        const newLock = new Promise((resolve) => {
+            unlock = resolve;
+        });
+        this.locks[key] = newLock;
+        try {
+            const accessKey = await provider.viewAccessKey({
+                accountId,
+                publicKey: pk,
+                finalityQuery: { finality: 'optimistic' },
+            });
+            this.nonces[key] = accessKey.nonce + 1n;
+            return this.nonces[key];
+        }
+        finally {
+            unlock();
+        }
+    }
+    async invalidate(pk) {
+        const key = pk.toString();
+        // make sure to wait until unlocked
+        const lock = this.locks[key];
+        if (lock)
+            await lock;
+        delete this.nonces[key];
+    }
+}

package/lib/providers/errors/contract_execution.d.ts

@@ -0,0 +1,152 @@
+import type { PrepareError, WasmTrap } from '../../rpc/types.gen.js';
+import type { BlockHash } from '../../types/index.js';
+import { HandlerError } from './handler.js';
+export declare class ContractExecutionError extends HandlerError {
+    readonly blockHash: BlockHash;
+    readonly blockHeight: number;
+    constructor(message: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class WasmTrapError extends ContractExecutionError {
+    readonly reason: WasmTrap;
+    constructor(reason: WasmTrap, blockHash: BlockHash, blockHeight: number);
+}
+export declare class ContractCodeDoesNotExistError extends ContractExecutionError {
+    readonly contractId: string;
+    constructor(contractId: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class ContractMethodNotFoundError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class ContractMethodNameEmptyError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class ContractMethodInvalidSignatureError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class PrepareWasmError extends ContractExecutionError {
+    readonly reason: PrepareError;
+    constructor(reason: PrepareError, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostBadUtf16Error extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostBadUtf8Error extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostGasExceededError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostGasLimitExceededError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostBalanceExceededError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostEmptyMethodNameError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostGuestPanicError extends ContractExecutionError {
+    readonly panicMessage: string;
+    constructor(panicMessage: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostIntegerOverflowError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidPromiseIndexError extends ContractExecutionError {
+    readonly promiseIndex: number;
+    constructor(promiseIndex: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostCannotAppendActionToJointPromiseError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostCannotReturnJointPromiseError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidPromiseResultIndexError extends ContractExecutionError {
+    readonly resultIndex: number;
+    constructor(resultIndex: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidRegisterIdError extends ContractExecutionError {
+    readonly registerId: number;
+    constructor(registerId: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostIteratorWasInvalidatedError extends ContractExecutionError {
+    readonly iteratorIndex: number;
+    constructor(iteratorIndex: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostMemoryAccessViolationError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidReceiptIndexError extends ContractExecutionError {
+    readonly receiptIndex: number;
+    constructor(receiptIndex: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidIteratorIndexError extends ContractExecutionError {
+    readonly iteratorIndex: number;
+    constructor(iteratorIndex: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidAccountIdError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidMethodNameError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostInvalidPublicKeyError extends ContractExecutionError {
+    constructor(blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostProhibitedInViewError extends ContractExecutionError {
+    readonly methodName: string;
+    constructor(methodName: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostNumberOfLogsExceededError extends ContractExecutionError {
+    readonly limit: number;
+    constructor(limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostKeyLengthExceededError extends ContractExecutionError {
+    readonly length: number;
+    readonly limit: number;
+    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostValueLengthExceededError extends ContractExecutionError {
+    readonly length: number;
+    readonly limit: number;
+    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostTotalLogLengthExceededError extends ContractExecutionError {
+    readonly length: number;
+    readonly limit: number;
+    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostNumberPromisesExceededError extends ContractExecutionError {
+    readonly limit: number;
+    readonly numberOfPromises: number;
+    constructor(limit: number, numberOfPromises: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostNumberInputDataDependenciesExceededError extends ContractExecutionError {
+    readonly limit: number;
+    readonly numberOfInputDataDependencies: number;
+    constructor(limit: number, numberOfInputDataDependencies: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostReturnedValueLengthExceededError extends ContractExecutionError {
+    readonly length: number;
+    readonly limit: number;
+    constructor(length: number, limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostSizeExceededError extends ContractExecutionError {
+    readonly size: number;
+    readonly limit: number;
+    constructor(size: number, limit: number, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostDeprecatedError extends ContractExecutionError {
+    readonly methodName: string;
+    constructor(methodName: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostECRecoverError extends ContractExecutionError {
+    constructor(message: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostAltBn128InvalidInputError extends ContractExecutionError {
+    constructor(message: string, blockHash: BlockHash, blockHeight: number);
+}
+export declare class HostEd25519VerifyInvalidInputError extends ContractExecutionError {
+    constructor(message: string, blockHash: BlockHash, blockHeight: number);
+}