Action Reference

This page documents every method available on the TransactionBuilder. To start a transaction:

near.transaction(signerId: string)

Token Operations

.transfer(receiverId, amount)

Sends NEAR tokens from the signer to the receiver.

string

required

The account receiving the tokens.

Amount

required

The amount to send (e.g. "10 NEAR", "0.5 NEAR", "1000 yocto").

.transfer("bob.near", "10 NEAR")

.stake(publicKey, amount)

Stakes NEAR with a validator.

string

required

The validator’s public key.

Amount

required

The amount to stake.

Contract Operations

.functionCall(contractId, methodName, args, options)

Calls a method on a smart contract.

string

required

The contract account ID.

string

required

The method to call.

object | Uint8Array

Arguments. Objects are automatically JSON serialized.

object

Show properties

Gas

default:"30 Tgas"

Computation limit.

Amount

default:"0 yocto"

NEAR to send to the contract.

.functionCall(
  "market.near",
  "buy",
  { item_id: "sword-1" },
  { gas: "50 Tgas", attachedDeposit: "1 NEAR" }
)

.deployContract(accountId, code)

Deploys Wasm code to an account. If the account already has a contract, it will be updated.

string

required

The account to deploy to.

Uint8Array

required

The raw bytes of the compiled Wasm file.

.stateInit(stateInit, options?)

Deploys a contract to a deterministic account ID (NEP-616). The address is auto-derived from the initialization state. Idempotent—refunds if already deployed.

object

required

Show properties

object

required

Global contract reference: { accountId: string } or { codeHash: string }

Map<Uint8Array, Uint8Array>

Initial storage key-value pairs (borsh-serialized bytes).

Amount

required

Storage cost reserve.

object

Show properties

string

Custom refund recipient.

const encoder = new TextEncoder();
.stateInit({
  code: { accountId: "publisher.near" },
  data: new Map([
    [encoder.encode("owner"), encoder.encode("alice.near")]
  ]),
  deposit: "1 NEAR",
})

See Global Contracts for more details.

Account Management

.createAccount(accountId)

Creates a new account. This is often chained with .transfer (to fund it) and .addKey (to secure it).

string

required

The full ID of the new account (must be a sub-account of the signer).

.createAccount("bob.alice.near")
.transfer("bob.alice.near", "1 NEAR")
.addKey(publicKey, { type: "fullAccess" })

.deleteAccount({ beneficiary })

Deletes the transaction receiver’s account and sends all remaining funds to the beneficiary.

string

required

The account that receives the remaining NEAR balance.

// Delete 'old-account.alice.near' and send remaining funds to 'alice.near'
await near
  .transaction("old-account.alice.near")
  .deleteAccount({ beneficiary: "alice.near" })
  .send()

Access Keys

.addKey(publicKey, permission)

Adds a new access key to the account.

string

required

The public key to add (ed25519 or secp256k1).

AccessKeyPermission

required

One of:

{ type: "fullAccess" } - Can do anything.
{ type: "functionCall", receiverId, methodNames?, allowance? } - Restricted to specific contracts/methods.

Full Access
Function Call (Restricted)

.addKey(pk, { type: "fullAccess" })

.addKey(pk, {
  type: "functionCall",
  receiverId: "app.near",
  methodNames: ["vote", "comment"],
  allowance: "0.25 NEAR" // Gas allowance
})

.deleteKey(accountId, publicKey)

Removes an access key.

string

required

The account to remove the key from.

string

required

The public key to remove.

Global Contracts

.publishContract(code, options?)

Publishes contract code to the global registry so others can deploy it by reference.

Uint8Array

required

The Wasm bytes.

object

Show properties

string

default:"account"

How the contract is referenced:

"account": Updatable by signer, identified by signer’s account ID
"hash": Immutable, identified by code hash

Updatable (default)
Immutable

// Identified by your account - you can update it later
.publishContract(wasm)

// Identified by hash - can never be changed
.publishContract(wasm, { identifiedBy: "hash" })

.deployFromPublished(reference)

Deploys contract code that was previously published to the registry. This saves gas by avoiding uploading the full Wasm bytes.

object

required

One of:

{ accountId: string } - Account ID of the publisher (for updatable contracts)
{ codeHash: string } - Base58 hash of an immutable contract

Advanced / Meta-Transactions

.delegate(options?)

Instead of sending the transaction, this method signs it and returns a SignedDelegateAction payload. This is used for meta-transactions where a relayer pays the gas.

object

Show properties

bigint

Expiration block.

string

default:"base64"

Output format: "base64" or "bytes".

Returns: { signedDelegateAction, payload, format }

.signedDelegateAction(signedDelegate)

Adds a pre-signed delegate action to this transaction. Used by relayers to submit a user’s action.

SignedDelegateAction

required

The signed delegate action from the user.

.signWith(key)

Overrides the signer for this specific transaction. Does not change the global Near configuration.

string | Signer

required

A private key string OR a custom signer function.

Private Key
Custom Signer

// Use a specific key just for this transaction
.signWith("ed25519:...")

// Use a custom signer (e.g. hardware wallet)
.signWith(async (hash) => {
  return ledger.sign(hash);
})

Getting Started

Essentials

React

Building dApps

Advanced

Reference

Token Operations

Contract Operations

Account Management

Access Keys

Global Contracts

Advanced / Meta-Transactions

​Token Operations

​Contract Operations

​Account Management

​Access Keys

​Global Contracts

​Advanced / Meta-Transactions

Token Operations

Contract Operations

Account Management

Access Keys

Global Contracts

Advanced / Meta-Transactions