Class TonClient

constructor

• new TonClient(parameters: TonClientParameters): TonClient

  Parameters

  • parameters: TonClientParameters

  Returns TonClient

Readonlyparameters

callGetMethod

• callGetMethod(
      address: Address,
      name: string,
      stack?: TupleItem[],
  ): Promise<{ gas_used: number; stack: TupleReader }>

  Invoke get method

  Parameters

  • address: Address

    contract address
  • name: string

    name of method
  • stack: TupleItem[] = []

  Returns Promise<{ gas_used: number; stack: TupleReader }>

  stack and gas_used field

  Deprecated

  use runMethod instead

callGetMethodWithError

• callGetMethodWithError(
      address: Address,
      name: string,
      stack?: TupleItem[],
  ): Promise<{ gas_used: number; stack: TupleReader }>

  Invoke get method that returns error code instead of throwing error

  Parameters

  • address: Address

    contract address
  • name: string

    name of method
  • stack: TupleItem[] = []

  Returns Promise<{ gas_used: number; stack: TupleReader }>

  stack and gas_used field

  Deprecated

  use runMethodWithError instead

estimateExternalMessageFee

• estimateExternalMessageFee(
      address: Address,
      args: {
          body: Cell;
          ignoreSignature: boolean;
          initCode: null | Cell;
          initData: null | Cell;
      },
  ): Promise<
      {
          "@type": "query.fees";
          source_fees: {
              "@type": "fees";
              fwd_fee: number;
              gas_fee: number;
              in_fwd_fee: number;
              storage_fee: number;
          };
      },
  >

  Estimate fees for external message

  Parameters

  • address: Address

    target address
  • args: {
        body: Cell;
        ignoreSignature: boolean;
        initCode: null | Cell;
        initData: null | Cell;
    }

  Returns Promise<
      {
          "@type": "query.fees";
          source_fees: {
              "@type": "fees";
              fwd_fee: number;
              gas_fee: number;
              in_fwd_fee: number;
              storage_fee: number;
          };
      },
  >

getBalance

• getBalance(address: Address): Promise<bigint>

  Get Address Balance

  Parameters

  • address: Address

    address for balance check

  Returns Promise<bigint>

  balance

getContractState

• getContractState(
      address: Address,
  ): Promise<
      {
          balance: bigint;
          blockId: { seqno: number; shard: string; workchain: number };
          code: null | Buffer;
          data: null | Buffer;
          extra_currencies:
              | undefined
              | { "@type": "extraCurrency"; amount: string; id: number }[];
          lastTransaction: null | { hash: string; lt: string };
          state: "active" | "uninitialized" | "frozen";
          timestampt: number;
      },
  >

  Resolves contract state

  Parameters

  • address: Address

    contract address

  Returns Promise<
      {
          balance: bigint;
          blockId: { seqno: number; shard: string; workchain: number };
          code: null | Buffer;
          data: null | Buffer;
          extra_currencies:
              | undefined
              | { "@type": "extraCurrency"; amount: string; id: number }[];
          lastTransaction: null | { hash: string; lt: string };
          state: "active" | "uninitialized" | "frozen";
          timestampt: number;
      },
  >

getMasterchainInfo

• getMasterchainInfo(): Promise<
      {
          initSeqno: number;
          latestSeqno: number;
          shard: string;
          workchain: number;
      },
  >

  Fetch latest masterchain info

  Returns Promise<
      {
          initSeqno: number;
          latestSeqno: number;
          shard: string;
          workchain: number;
      },
  >

  masterchain info

getShardTransactions

• getShardTransactions(
      workchain: number,
      seqno: number,
      shard: string,
  ): Promise<{ account: Address; hash: string; lt: string }[]>

  Fetch transactions inf shards

  Parameters

  • workchain: number
  • seqno: number
  • shard: string

  Returns Promise<{ account: Address; hash: string; lt: string }[]>

getTransaction

• getTransaction(
      address: Address,
      lt: string,
      hash: string,
  ): Promise<null | Transaction>

  Get transaction by it's id

  Parameters

  • address: Address

    address
  • lt: string

    logical time
  • hash: string

    transaction hash

  Returns Promise<null | Transaction>

  transaction or null if not exist

getTransactions

• getTransactions(
      address: Address,
      opts: {
          archival?: boolean;
          hash?: string;
          inclusive?: boolean;
          limit: number;
          lt?: string;
          to_lt?: string;
      },
  ): Promise<Transaction[]>

  Get transactions

  Parameters

  • address: Address

    address
  • opts: {
        archival?: boolean;
        hash?: string;
        inclusive?: boolean;
        limit: number;
        lt?: string;
        to_lt?: string;
    }

  Returns Promise<Transaction[]>

getWorkchainShards

• getWorkchainShards(
      seqno: number,
  ): Promise<{ seqno: number; shard: string; workchain: number }[]>

  Fetch latest workchain shards

  Parameters

  • seqno: number

    masterchain seqno

  Returns Promise<{ seqno: number; shard: string; workchain: number }[]>

isContractDeployed

• isContractDeployed(address: Address): Promise<boolean>

  Check if contract is deployed

  Parameters

  • address: Address

    addres to check

  Returns Promise<boolean>

  true if contract is in active state

open

• open<T extends Contract>(src: T): OpenedContract<T>

  Open contract

  Type Parameters

  • T extends Contract

  Parameters

  • src: T

    source contract

  Returns OpenedContract<T>

  contract

provider

• provider(address: Address, init?: null | StateInit): ContractProvider

  Create a provider

  Parameters

  • address: Address

    address
  • Optionalinit: null | StateInit

    optional init

  Returns ContractProvider

  provider

runMethod

• runMethod(
      address: Address,
      name: string,
      stack?: TupleItem[],
  ): Promise<{ gas_used: number; stack: TupleReader }>

  Invoke get method

  Parameters

  • address: Address

    contract address
  • name: string

    name of method
  • stack: TupleItem[] = []

  Returns Promise<{ gas_used: number; stack: TupleReader }>

  stack and gas_used field

runMethodWithError

• runMethodWithError(
      address: Address,
      name: string,
      params?: any[],
  ): Promise<{ exit_code: number; gas_used: number; stack: TupleReader }>

  Invoke get method that returns error code instead of throwing error

  Parameters

  • address: Address

    contract address
  • name: string

    name of method
  • params: any[] = []

    optional parameters

  Returns Promise<{ exit_code: number; gas_used: number; stack: TupleReader }>

  stack and gas_used field

sendExternalMessage

• sendExternalMessage(contract: Contract, src: Cell): Promise<void>

  Send external message to contract

  Parameters

  • contract: Contract

    contract to send message
  • src: Cell

    message body

  Returns Promise<void>

sendFile

• sendFile(src: Buffer): Promise<void>

  Send file to a network

  Parameters

  • src: Buffer

    source file

  Returns Promise<void>

sendMessage

• sendMessage(src: Message): Promise<void>

  Send message to a network

  Parameters

  • src: Message

    source message

  Returns Promise<void>

tryLocateResultTx

• tryLocateResultTx(
      source: Address,
      destination: Address,
      created_lt: string,
  ): Promise<Transaction>

  Locate outcoming transaction of destination address by incoming message

  Parameters

  • source: Address

    message source address
  • destination: Address

    message destination address
  • created_lt: string

    message's created lt

  Returns Promise<Transaction>

  transaction

tryLocateSourceTx

• tryLocateSourceTx(
      source: Address,
      destination: Address,
      created_lt: string,
  ): Promise<Transaction>

  Locate incoming transaction of source address by outcoming message

  Parameters

  • source: Address

    message source address
  • destination: Address

    message destination address
  • created_lt: string

    message's created lt

  Returns Promise<Transaction>

  transaction