Class Account

constructor

• new Account(
      accountId: string,
      provider: string | Provider,
      signer?: KeyPairString | Signer,
  ): Account

  Parameters

  • accountId: string
  • provider: string | Provider
  • Optionalsigner: KeyPairString | Signer

  Returns Account

ReadonlyaccountId

Readonlyprovider

addFullAccessKey

• addFullAccessKey(publicKey: string | PublicKey): Promise<RpcTransactionResponse>

  Add a full access key to the account

  Parameters

  • publicKey: string | PublicKey

    The public key to be added

  Returns Promise<RpcTransactionResponse>

addFunctionCallAccessKey

• addFunctionCallAccessKey(
      options: AddFunctionAccessKeyArgs,
  ): Promise<RpcTransactionResponse>

  Parameters

  • options: AddFunctionAccessKeyArgs

    • Optionalallowance?: string | number | bigint

    • contractId: string

    • OptionalmethodNames?: string[]

    • publicKey: string | PublicKey

  Returns Promise<RpcTransactionResponse>

callFunction

• callFunction<T extends SerializedReturnValue>(
      params: CallFunctionArgs,
  ): Promise<T>

  Call a function on a smart contract and return parsed transaction result

  Type Parameters

  • T extends SerializedReturnValue

  Parameters

  • params: CallFunctionArgs

    Call function parameters

    • Optionalargs?: Uint8Array<ArrayBufferLike> | Record<string, any>

    • contractId: string

    • Optionaldeposit?: string | number | bigint

    • Optionalgas?: string | number | bigint

    • methodName: string

    • OptionalwaitUntil?: TxExecutionStatus

  Returns Promise<T>

callFunctionRaw

• callFunctionRaw(params: CallFunctionArgs): Promise<RpcTransactionResponse>

  Call a function on a smart contract and return raw transaction outcome

  Parameters

  • params: CallFunctionArgs

    Call function parameters

    • Optionalargs?: Uint8Array<ArrayBufferLike> | Record<string, any>

    • contractId: string

    • Optionaldeposit?: string | number | bigint

    • Optionalgas?: string | number | bigint

    • methodName: string

    • OptionalwaitUntil?: TxExecutionStatus

  Returns Promise<RpcTransactionResponse>

createAccount

• createAccount(options: CreateAccountArgs): Promise<RpcTransactionResponse>

  Creates a new NEAR account with a given ID and public key.

  This method can create two types of accounts:

  1. Top-level accounts of the form name.tla (e.g., bob.near):

  2. Sub-accounts of the current account (e.g., sub.ana.near):

     • The new account ID must end with the current account ID
     • Example: If your account is ana.near, you can create sub.ana.near

  Parameters

  • options: CreateAccountArgs

    Account creation options

    • OptionalnearToTransfer?: string | number | bigint

    • newAccountId: string

    • publicKey: string | PublicKey

  Returns Promise<RpcTransactionResponse>

createMetaTransaction

• createMetaTransaction(
      options: CreateMetaTransactionArgs,
  ): Promise<DelegateAction>

  Create a meta transaction ready to be signed by a Signer

  Parameters

  • options: CreateMetaTransactionArgs

    Meta transaction options

    • actions: Action[]

    • OptionalblockHeightTtl?: number

    • publicKey: string | PublicKey

    • receiverId: string

  Returns Promise<DelegateAction>

createSignedMetaTransaction

• createSignedMetaTransaction(
      options: CreateSignedMetaTransactionArgs,
  ): Promise<SignDelegateActionReturn>

  Create a signed MetaTransaction that can be broadcasted to a relayer

  Parameters

  • options: CreateSignedMetaTransactionArgs

    Signed meta transaction options

    • actions: Action[]

    • OptionalblockHeightTtl?: number

    • receiverId: string

    • Optionalsigner?: Signer

  Returns Promise<SignDelegateActionReturn>

createSignedTransaction

• createSignedTransaction(
      __namedParameters: CreateSignedTransactionArgs,
  ): Promise<SignedTransaction>

  Create a signed transaction ready to be broadcast by a Provider

  Parameters

  • __namedParameters: CreateSignedTransactionArgs

  Returns Promise<SignedTransaction>

createSubAccount

• createSubAccount(options: CreateSubAccountArgs): Promise<RpcTransactionResponse>

  Creates a sub account of this account. For example, if the account is ana.near, you can create sub.ana.near.

  Parameters

  • options: CreateSubAccountArgs

    Sub-account creation options

    • accountOrPrefix: string

    • OptionalnearToTransfer?: string | number | bigint

    • publicKey: string | PublicKey

  Returns Promise<RpcTransactionResponse>

createTransaction

• createTransaction(options: CreateTransactionArgs): Promise<Transaction>

  Create a transaction that can be later signed with a Signer

  Parameters

  • options: CreateTransactionArgs

    Transaction options

    • actions: Action[]

    • publicKey: string | PublicKey

    • receiverId: string

  Returns Promise<Transaction>

deleteAccount

• deleteAccount(beneficiaryId: string): Promise<RpcTransactionResponse>

  Deletes the account, transferring all remaining NEAR to a beneficiary account

  Important: Deleting an account does not transfer FTs or NFTs

  Parameters

  • beneficiaryId: string

    Will receive the account's remaining balance

  Returns Promise<RpcTransactionResponse>

deleteKey

• deleteKey(publicKey: string | PublicKey): Promise<RpcTransactionResponse>

  Parameters

  • publicKey: string | PublicKey

    The public key to be deleted

  Returns Promise<RpcTransactionResponse>

deployContract

• deployContract(code: Uint8Array): Promise<RpcTransactionResponse>

  Deploy a smart contract in the account

  Parameters

  • code: Uint8Array

    The compiled contract code bytes

  Returns Promise<RpcTransactionResponse>

deployGlobalContract

• deployGlobalContract(
      code: Uint8Array,
      deployMode: "accountId" | "codeHash",
  ): Promise<RpcTransactionResponse>

  Deploy a global contract that can be reused by multiple accounts

  Parameters

  • code: Uint8Array

    The compiled contract code bytes

  • deployMode: "accountId" | "codeHash"

    Deploy mode - "codeHash" for immutable contracts, "accountId" for updateable contracts

  Returns Promise<RpcTransactionResponse>

getAccessKey

• getAccessKey(publicKey: string | PublicKey): Promise<AccessKeyView>

  Calls Provider.viewAccessKey to retrieve information for a specific key in the account

  Parameters

  • publicKey: string | PublicKey

  Returns Promise<AccessKeyView>

getAccessKeyList

• getAccessKeyList(): Promise<
      AccessKeyList & { block_hash: string; block_height: number },
  >

  Calls Provider.viewAccessKeyList to retrieve the account's keys

  Returns Promise<AccessKeyList & { block_hash: string; block_height: number }>

getBalance

• getBalance(token?: NativeToken | FungibleToken): Promise<bigint>

  Parameters

  • token: NativeToken | FungibleToken = NEAR

    The token to check the balance of. Defaults to Native NEAR.

  Returns Promise<bigint>

  The available balance of the account in units (e.g. yoctoNEAR).

getContractCode

• getContractCode(): Promise<ContractCodeView>

  Calls Provider.viewContractCode to retrieve the account's contract code and its hash

  Returns Promise<ContractCodeView>

getContractState

• getContractState(
      prefix?: string,
  ): Promise<ViewStateResult & { block_hash: string; block_height: number }>

  Calls Provider.viewContractState to retrieve the keys and values stored on the account's contract

  Parameters

  • Optionalprefix: string

  Returns Promise<ViewStateResult & { block_hash: string; block_height: number }>

getSigner

• getSigner(): Signer | undefined

  Returns Signer | undefined

getState

• getState(): Promise<AccountState>

  Returns an overview of the account's state, including the account's balance, storage usage, and code hash

  Returns Promise<AccountState>

setSigner

• setSigner(signer: Signer): void

  Allows to set the signer used to control the account

  Parameters

  • signer: Signer

    holds the private key and can sign Transactions

  Returns void

signAndSendTransaction

• signAndSendTransaction(
      options: SignAndSendTransactionArgs,
  ): Promise<RpcTransactionResponse>

  Creates a transaction, signs it and broadcast it to the network

  Parameters

  • options: SignAndSendTransactionArgs

    Sign and send transaction options

    • actions: Action[]

    • receiverId: string

    • Optionalretries?: number

    • Optionalsigner?: Signer

    • OptionalthrowOnFailure?: boolean

    • OptionalwaitUntil?: TxExecutionStatus

  Returns Promise<RpcTransactionResponse>

signAndSendTransactions

• signAndSendTransactions(
      __namedParameters: SignAndSendTransactionsArgs,
  ): Promise<RpcTransactionResponse[]>

  Parameters

  • __namedParameters: SignAndSendTransactionsArgs

  Returns Promise<RpcTransactionResponse[]>

signNep413Message

• signNep413Message(args: SignNep413MessageArgs): Promise<SignedMessage>

  This function simply calls the signNep413Message method of the Signer

  Parameters

  • args: SignNep413MessageArgs

    Nep413 message signing arguments

    • OptionalcallbackUrl?: string

    • message: string

    • nonce: Uint8Array

    • recipient: string

  Returns Promise<SignedMessage>

  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.

transfer

• transfer(options: TransferArgs): Promise<RpcTransactionResponse>

  Transfers a token to the specified receiver.

  Supports sending either the native NEAR token or any supported Fungible Token (FT).

  Parameters

  • options: TransferArgs

    Transfer options

    • amount: string | number | bigint

    • receiverId: string

    • Optionaltoken?: NativeToken | FungibleToken

  Returns Promise<RpcTransactionResponse>

useGlobalContract

• useGlobalContract(
      contractIdentifier:
          | { accountId: string }
          | { codeHash: string | Uint8Array<ArrayBufferLike> },
  ): Promise<RpcTransactionResponse>

  Use a previously deployed global contract on this account

  Parameters

  • contractIdentifier: { accountId: string } | { codeHash: string | Uint8Array<ArrayBufferLike> }

    The global contract identifier - either { accountId: string } or { codeHash: string | Uint8Array }

  Returns Promise<RpcTransactionResponse>