Class ProviderRpcClient

constructor

• new ProviderRpcClient(properties?: ProviderProperties): ProviderRpcClient

  Parameters

  • properties: ProviderProperties = {}

  Returns ProviderRpcClient

Contract

Subscriber

isInitialized

• get isInitialized(): boolean

  Whether provider api is ready

  Returns boolean

raw

• get raw(): Provider

  Raw provider

  Returns Provider

rawApi

• get rawApi(): RawProviderApiMethods

  Raw provider api

  Returns RawProviderApiMethods

hasProvider

• hasProvider(): Promise<boolean>

  Checks whether this page has injected Everscale provider or there is a fallback provider.

  Returns Promise<boolean>

ensureInitialized

• ensureInitialized(): Promise<void>

  Waits until provider api will be available. Calls fallback if no provider was found

  Returns Promise<void>

  Throws

  ProviderNotFoundException when no provider found

createContract

• createContract<Abi>(abi: Abi, address: Address): Contract<Abi>

  Creates typed contract wrapper.

  Type Parameters

  • Abi

  Parameters

  • abi: Abi

    Readonly object (must be declared with as const)

  • address: Address

    Default contract address

  Returns Contract<Abi>

  Deprecated

  new ever.Contract(abi, address) should be used instead

createSubscriber

• createSubscriber(): Subscriber

  Creates subscriptions group

  Returns Subscriber

  Deprecated

  new ever.Subscriber() should be used instead

requestPermissions

• requestPermissions(
      args: { permissions: (keyof Permissions<Address>)[] },
  ): Promise<Partial<Permissions<Address>>>

  Requests new permissions for current origin. Shows an approval window to the user. Will overwrite already existing permissions

  ---

  Required permissions: none

  Parameters

  • args: { permissions: (keyof Permissions<Address>)[] }

  Returns Promise<Partial<Permissions<Address>>>

changeAccount

• changeAccount(): Promise<void>

  Updates accountInteraction permission value

  ---

  Requires permissions: accountInteraction

  Returns Promise<void>

disconnect

• disconnect(): Promise<void>

  Removes all permissions for current origin and stops all subscriptions

  Returns Promise<void>

subscribe

• subscribe(
      eventName: "contractStateChanged",
      params: { address: Address },
  ): Promise<Subscription<"contractStateChanged">>

  Called every time contract state changes

  Parameters

  • eventName: "contractStateChanged"
  • params: { address: Address }

  Returns Promise<Subscription<"contractStateChanged">>

• subscribe(
      eventName: "transactionsFound",
      params: { address: Address },
  ): Promise<Subscription<"transactionsFound">>

  Called on each new transactions batch, received on subscription

  Parameters

  • eventName: "transactionsFound"
  • params: { address: Address }

  Returns Promise<Subscription<"transactionsFound">>

• subscribe(eventName: "connected"): Promise<Subscription<"connected">>

  Called every time when provider connection is established

  Parameters

  • eventName: "connected"

  Returns Promise<Subscription<"connected">>

• subscribe(eventName: "disconnected"): Promise<Subscription<"disconnected">>

  Called when inpage provider disconnects from extension

  Parameters

  • eventName: "disconnected"

  Returns Promise<Subscription<"disconnected">>

• subscribe(
      eventName: "messageStatusUpdated",
  ): Promise<Subscription<"messageStatusUpdated">>

  Called every time a delayed message was delivered or expired

  Parameters

  • eventName: "messageStatusUpdated"

  Returns Promise<Subscription<"messageStatusUpdated">>

• subscribe(eventName: "networkChanged"): Promise<Subscription<"networkChanged">>

  Called each time the user changes network

  Parameters

  • eventName: "networkChanged"

  Returns Promise<Subscription<"networkChanged">>

• subscribe(
      eventName: "permissionsChanged",
  ): Promise<Subscription<"permissionsChanged">>

  Called when permissions are changed. Mostly when account has been removed from the current accountInteraction permission, or disconnect method was called

  Parameters

  • eventName: "permissionsChanged"

  Returns Promise<Subscription<"permissionsChanged">>

• subscribe(eventName: "loggedOut"): Promise<Subscription<"loggedOut">>

  Called when the user logs out of the extension

  Parameters

  • eventName: "loggedOut"

  Returns Promise<Subscription<"loggedOut">>

getProviderState

• getProviderState(): Promise<
      {
          version: string;
          numericVersion: number;
          selectedConnection: string;
          networkId: number;
          supportedPermissions: (keyof Permissions<Address>)[];
          permissions: Partial<Permissions<Addr>>;
          subscriptions: { [address: string]: ContractUpdatesSubscription };
      },
  >

  Returns provider api state

  ---

  Required permissions: none

  Returns Promise<
      {
          version: string;
          numericVersion: number;
          selectedConnection: string;
          networkId: number;
          supportedPermissions: (keyof Permissions<Address>)[];
          permissions: Partial<Permissions<Addr>>;
          subscriptions: { [address: string]: ContractUpdatesSubscription };
      },
  >

getBalance

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

  Requests contract balance

  ---

  Required permissions: basic

  Parameters

  • address: Address

  Returns Promise<string>

getFullContractState

• getFullContractState(
      args: { address: Address },
  ): Promise<{ state: FullContractState | undefined }>

  Requests contract data

  ---

  Required permissions: basic

  Parameters

  • args: { address: Address }

    • address: Address

      Contract address

  Returns Promise<{ state: FullContractState | undefined }>

computeStorageFee

• computeStorageFee(
      args: {
          state: FullContractState;
          masterchain?: boolean;
          timestamp?: number;
      },
  ): Promise<
      {
          storageFee: string;
          storageFeeDebt?: string;
          accountStatus: AccountStatus;
          freezeDueLimit: string;
          deleteDueLimit: string;
      },
  >

  Compute storage fee

  ---

  Required permissions: basic

  Parameters

  • args: { state: FullContractState; masterchain?: boolean; timestamp?: number }

    • state: FullContractState

      Existing contract state

    • Optionalmasterchain?: boolean

      Whether to assume that the contract is in the masterchain. Default: false

    • Optionaltimestamp?: number

      Optional UNIX timestamp (in seconds) of the moment up to which the storage fee is calculated. Default: current timestamp

      NOTE: for a time that was earlier than the last state update, the last_paid time will be used.

  Returns Promise<
      {
          storageFee: string;
          storageFeeDebt?: string;
          accountStatus: AccountStatus;
          freezeDueLimit: string;
          deleteDueLimit: string;
      },
  >

getAccountsByCodeHash

• getAccountsByCodeHash(
      args: { codeHash: string; continuation?: string; limit?: number },
  ): Promise<{ accounts: Address[]; continuation: string | undefined }>

  Requests accounts with specified code hash

  ---

  Required permissions: basic

  Parameters

  • args: { codeHash: string; continuation?: string; limit?: number }

    • codeHash: string

      Hex encoded code hash

    • Optionalcontinuation?: string

      Last address from previous batch

    • Optionallimit?: number

      Optional limit. Values grater than 50 have no effect

  Returns Promise<{ accounts: Address[]; continuation: string | undefined }>

getTransactions

• getTransactions(
      args: { address: Address; continuation?: TransactionId; limit?: number },
  ): Promise<
      {
          transactions: Transaction<Address>[];
          continuation: TransactionId | undefined;
          info?: TransactionsBatchInfo;
      },
  >

  Requests contract transactions

  ---

  Required permissions: basic

  Parameters

  • args: { address: Address; continuation?: TransactionId; limit?: number }

    • address: Address

      Contract address

    • Optionalcontinuation?: TransactionId

      Id of the transaction from which to request the next batch

    • Optionallimit?: number

      Optional limit. Values greater than 50 have no effect

  Returns Promise<
      {
          transactions: Transaction<Address>[];
          continuation: TransactionId | undefined;
          info?: TransactionsBatchInfo;
      },
  >

getTransaction

• getTransaction(
      args: { hash: string },
  ): Promise<{ transaction: Transaction<Address> | undefined }>

  Searches transaction by hash

  ---

  Required permissions: basic

  Parameters

  • args: { hash: string }

    • hash: string

      Hex encoded transaction hash

  Returns Promise<{ transaction: Transaction<Address> | undefined }>

getExpectedAddress

• getExpectedAddress<Abi>(
      abi: Abi,
      args: GetExpectedAddressParams<Abi>,
  ): Promise<Address>

  Computes contract address from code and init params

  ---

  Required permissions: basic

  Type Parameters

  • Abi

  Parameters

  • abi: Abi
  • args: GetExpectedAddressParams<Abi>

  Returns Promise<Address>

getStateInit

• getStateInit<Abi>(
      abi: Abi,
      args: GetExpectedAddressParams<Abi>,
  ): Promise<{ address: Address; stateInit: string; hash: string }>

  Computes contract address and state from code and init params

  ---

  Required permissions: basic

  Type Parameters

  • Abi

  Parameters

  • abi: Abi
  • args: GetExpectedAddressParams<Abi>

  Returns Promise<{ address: Address; stateInit: string; hash: string }>

unpackInitData

• unpackInitData<Abi>(
      abi: Abi,
      data: string,
  ): Promise<{ publicKey?: string; initParams: DecodedAbiInitData<Abi> }>

  Decodes initial contract data using the specified ABI

  ---

  Required permissions: basic

  Type Parameters

  • Abi

  Parameters

  • abi: Abi
  • data: string

  Returns Promise<{ publicKey?: string; initParams: DecodedAbiInitData<Abi> }>

getBocHash

• getBocHash(boc: string): Promise<string>

  Computes hash of base64 encoded BOC

  ---

  Required permissions: basic

  Parameters

  • boc: string

  Returns Promise<string>

packIntoCell

• packIntoCell<P extends readonly ReadonlyAbiParam[]>(
      args: {
          abiVersion?: AbiVersion;
          structure: P;
          data: MergeInputObjectsArray<P>;
      },
  ): Promise<{ boc: string; hash: string }>

  Creates base64 encoded BOC

  ---

  Required permissions: basic

  Type Parameters

  • P extends readonly ReadonlyAbiParam[]

  Parameters

  • args: { abiVersion?: AbiVersion; structure: P; data: MergeInputObjectsArray<P> }

  Returns Promise<{ boc: string; hash: string }>

unpackFromCell

• unpackFromCell<P extends readonly ReadonlyAbiParam[]>(
      args: {
          abiVersion?: AbiVersion;
          structure: P;
          boc: string;
          allowPartial: boolean;
      },
  ): Promise<{ data: MergeOutputObjectsArray<P> }>

  Decodes base64 encoded BOC

  ---

  Required permissions: basic

  Type Parameters

  • P extends readonly ReadonlyAbiParam[]

  Parameters

  • args: { abiVersion?: AbiVersion; structure: P; boc: string; allowPartial: boolean }

  Returns Promise<{ data: MergeOutputObjectsArray<P> }>

extractPublicKey

• extractPublicKey(boc: string): Promise<string>

  Extracts public key from raw account state

  NOTE: can only be used on contracts which are deployed and has pubkey header

  ---

  Required permissions: basic

  Parameters

  • boc: string

  Returns Promise<string>

codeToTvc

• codeToTvc(code: string): Promise<string>

  Converts base64 encoded contract code into tvc with default init data

  ---

  Required permissions: basic

  Parameters

  • code: string

  Returns Promise<string>

mergeTvc

• mergeTvc(
      args: { code: string; data: string },
  ): Promise<{ tvc: string; hash: string }>

  Merges code and data into state init

  ---

  Required permissions: basic

  Parameters

  • args: { code: string; data: string }

    • code: string

      Base64 encoded contract code

    • data: string

      Base64 encoded contract data

  Returns Promise<{ tvc: string; hash: string }>

splitTvc

• splitTvc(
      tvc: string,
  ): Promise<{ data: string | undefined; code: string | undefined }>

  Splits base64 encoded state init into code and data

  ---

  Required permissions: basic

  Parameters

  • tvc: string

  Returns Promise<{ data: string | undefined; code: string | undefined }>

setCodeSalt

• setCodeSalt<P extends readonly ReadonlyAbiParam[]>(
      args: SetCodeSaltParams<P>,
  ): Promise<{ code: string; hash: string }>

  Merges code and data into state init

  ---

  Required permissions: basic

  Type Parameters

  • P extends readonly ReadonlyAbiParam[]

  Parameters

  • args: SetCodeSaltParams<P>

  Returns Promise<{ code: string; hash: string }>

getCodeSalt

• getCodeSalt(args: GetCodeSaltParams): Promise<string | undefined>

  Retrieves salt from code. Returns undefined if code doesn't contain salt

  ---

  Required permissions: basic

  Parameters

  • args: GetCodeSaltParams

  Returns Promise<string | undefined>

addAsset

• addAsset<T extends "tip3_token">(
      args: AddAssetParams<T>,
  ): Promise<{ newAsset: boolean }>

  Adds asset to the selected account

  ---

  Requires permissions: accountInteraction

  Type Parameters

  • T extends "tip3_token"

  Parameters

  • args: AddAssetParams<T>

  Returns Promise<{ newAsset: boolean }>

verifySignature

• verifySignature(
      args: {
          publicKey: string;
          dataHash: string;
          signature: string;
          withSignatureId?: number | boolean;
          withSignatureContext?: SignatureContext;
      },
  ): Promise<{ isValid: boolean }>

  Parameters

  • args: {
        publicKey: string;
        dataHash: string;
        signature: string;
        withSignatureId?: number | boolean;
        withSignatureContext?: SignatureContext;
    }

    • publicKey: string

      The public key of the preferred account. It is the same publicKey as the accountInteraction.publicKey, but it must be explicitly provided

    • dataHash: string

      Base64 or hex encoded arbitrary bytes hash (data must be 32 bytes long)

    • signature: string

      Base64 or hex encoded signature bytes (data must be 64 bytes long)

    • OptionalwithSignatureId?: number | boolean

      Whether to use the signature id during verification (true by default).

      • If true, uses the signature id of the selected network (if the capability is enabled).
      • If false, forces signature check to ignore any signature id.
      • If number, uses the specified number as a signature id.

      Deprecated

      Use withSignatureContext instead.

    • OptionalwithSignatureContext?: SignatureContext

      Optional advanced signature configuration.

      In most cases you do not need to set this manually. The wallet or network configuration will choose the correct mode.

      This field controls how the data is prepared before signing:

      • empty — signs the data as-is. Use for simple or legacy signing.

      • signatureId — signs the data together with a network-specific id. Prevents signatures from being reused on another network.

      • signatureDomainL2 — same as signature id but with a different prefix. This should be used where the SignatureDomain capability is enabled.

      If provided, this field overrides withSignatureId.

  Returns Promise<{ isValid: boolean }>

signData

• signData(
      args: {
          publicKey: string;
          data: string;
          withSignatureId?: number | boolean;
          withSignatureContext?: SignatureContext;
      },
  ): Promise<
      {
          dataHash: string;
          signature: string;
          signatureHex: string;
          signatureParts: { high: string; low: string };
      },
  >

  Signs arbitrary data.

  NOTE: hashes data before signing. Use signDataRaw to sign without hash.

  ---

  Requires permissions: accountInteraction

  Parameters

  • args: {
        publicKey: string;
        data: string;
        withSignatureId?: number | boolean;
        withSignatureContext?: SignatureContext;
    }

    • publicKey: string

      The public key of the preferred account. It is the same publicKey as the accountInteraction.publicKey, but it must be explicitly provided

    • data: string

      Base64 encoded arbitrary bytes

    • OptionalwithSignatureId?: number | boolean

      Whether to use the signature id for signing (true by default).

      • If true, uses the signature id of the selected network (if the capability is enabled).
      • If false, forces signature check to ignore any signature id.
      • If number, uses the specified number as a signature id.

      Deprecated

      Use withSignatureContext instead.

    • OptionalwithSignatureContext?: SignatureContext

      Optional advanced signature configuration.

      In most cases you do not need to set this manually. The wallet or network configuration will choose the correct mode.

      This field controls how the data is prepared before signing:

      • empty — signs the data as-is. Use for simple or legacy signing.

      • signatureId — signs the data together with a network-specific id. Prevents signatures from being reused on another network.

      • signatureDomainL2 — same as signature id but with a different prefix. This should be used where the SignatureDomain capability is enabled.

      If provided, this field overrides withSignatureId.

  Returns Promise<
      {
          dataHash: string;
          signature: string;
          signatureHex: string;
          signatureParts: { high: string; low: string };
      },
  >

signDataRaw

• signDataRaw(
      args: {
          publicKey: string;
          data: string;
          withSignatureId?: number | boolean;
          withSignatureContext?: SignatureContext;
      },
  ): Promise<
      {
          signature: string;
          signatureHex: string;
          signatureParts: { high: string; low: string };
      },
  >

  Signs arbitrary data without hashing it

  ---

  Requires permissions: accountInteraction

  Parameters

  • args: {
        publicKey: string;
        data: string;
        withSignatureId?: number | boolean;
        withSignatureContext?: SignatureContext;
    }

    • publicKey: string

      The public key of the preferred account. It is the same publicKey as the accountInteraction.publicKey, but it must be explicitly provided

    • data: string

      Base64 encoded arbitrary bytes

    • OptionalwithSignatureId?: number | boolean

      Whether to use the signature id for signing (true by default).

      • If true, uses the signature id of the selected network (if the capability is enabled).
      • If false, forces signature check to ignore any signature id.
      • If number, uses the specified number as a signature id.

      Deprecated

      Use withSignatureContext instead.

    • OptionalwithSignatureContext?: SignatureContext

      Optional advanced signature configuration.

      In most cases you do not need to set this manually. The wallet or network configuration will choose the correct mode.

      This field controls how the data is prepared before signing:

      • empty — signs the data as-is. Use for simple or legacy signing.

      • signatureId — signs the data together with a network-specific id. Prevents signatures from being reused on another network.

      • signatureDomainL2 — same as signature id but with a different prefix. This should be used where the SignatureDomain capability is enabled.

      If provided, this field overrides withSignatureId.

  Returns Promise<
      {
          signature: string;
          signatureHex: string;
          signatureParts: { high: string; low: string };
      },
  >

encryptData

• encryptData(
      args: {
          publicKey: string;
          recipientPublicKeys: string[];
          algorithm: "ChaCha20Poly1305";
          data: string;
      },
  ): Promise<EncryptedData[]>

  Encrypts arbitrary data with specified algorithm for each specified recipient

  ---

  Requires permissions: accountInteraction

  Parameters

  • args: {
        publicKey: string;
        recipientPublicKeys: string[];
        algorithm: "ChaCha20Poly1305";
        data: string;
    }

    • publicKey: string

      The public key of the preferred account. It is the same publicKey as the accountInteraction.publicKey, but it must be explicitly provided

    • recipientPublicKeys: string[]

      Public keys of recipients. Hex encoded

    • algorithm: "ChaCha20Poly1305"

      Encryption algorithm. Nonce will be generated for each recipient

    • data: string

      Base64 encoded data

  Returns Promise<EncryptedData[]>

decryptData

• decryptData(encryptedData: EncryptedData): Promise<string>

  Decrypts encrypted data. Returns base64 encoded data

  ---

  Requires permissions: accountInteraction

  Parameters

  • encryptedData: EncryptedData

  Returns Promise<string>

sendMessage

• sendMessage(
      args: {
          sender: Address;
          recipient: Address;
          amount: string;
          bounce: boolean;
          payload?: FunctionCall<Address>;
          stateInit?: string;
          ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
          ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
      },
  ): Promise<{ transaction: Transaction<Address> }>

  Sends an internal message from the user account. Shows an approval window to the user.

  ---

  Required permissions: accountInteraction

  Parameters

  • args: {
        sender: Address;
        recipient: Address;
        amount: string;
        bounce: boolean;
        payload?: FunctionCall<Address>;
        stateInit?: string;
        ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
        ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
    }

    • sender: Address

      Preferred wallet address. It is the same address as the accountInteraction.address, but it must be explicitly provided

    • recipient: Address

      Message destination address

    • amount: string

      Amount of nano EVER to send

    • bounce: boolean

      Whether to bounce message back on error

    • Optionalpayload?: FunctionCall<Address>

      Optional function call

    • OptionalstateInit?: string

      Optional base64 encoded TVC

      NOTE: If the selected contract do not support this, an error is returned

    • OptionalignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[]

      Optional compute phase error codes to be ignored during transaction tree simulation

    • OptionalignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[]

      Optional action phase error codes to be ignored during transaction tree simulation

  Returns Promise<{ transaction: Transaction<Address> }>

sendMessageDelayed

• sendMessageDelayed(
      args: {
          sender: Address;
          recipient: Address;
          amount: string;
          bounce: boolean;
          payload?: FunctionCall<Address>;
          stateInit?: string;
          ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
          ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
      },
  ): Promise<DelayedMessageExecution>

  Sends an internal message from the user account without waiting for the transaction. Shows an approval window to the user.

  Parameters

  • args: {
        sender: Address;
        recipient: Address;
        amount: string;
        bounce: boolean;
        payload?: FunctionCall<Address>;
        stateInit?: string;
        ignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
        ignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[];
    }

    • sender: Address

      Preferred wallet address. It is the same address as the accountInteraction.address, but it must be explicitly provided

    • recipient: Address

      Message destination address

    • amount: string

      Amount of nano EVER to send

    • bounce: boolean

      Whether to bounce message back on error

    • Optionalpayload?: FunctionCall<Address>

      Optional function call

    • OptionalstateInit?: string

      Optional base64 encoded TVC

      NOTE: If the selected contract do not support this, an error is returned

    • OptionalignoredComputePhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[]

      Optional compute phase error codes to be ignored during transaction tree simulation

    • OptionalignoredActionPhaseCodes?: IgnoreTransactionTreeSimulationError<Address>[]

      Optional action phase error codes to be ignored during transaction tree simulation

  Returns Promise<DelayedMessageExecution>

  See

  messageStatusUpdated

  ---

  Required permissions: accountInteraction

addNetwork

• addNetwork(
      args: { network: AddNetwork; switchNetwork?: boolean },
  ): Promise<{ network: Network | null }>

  Request user to add a new network. Shows an approval window to the user.

  ---

  Required permissions: basic

  Parameters

  • args: { network: AddNetwork; switchNetwork?: boolean }

    • network: AddNetwork

      Network info

    • OptionalswitchNetwork?: boolean

      Whether to switch to the added network (false by default)

  Returns Promise<{ network: Network | null }>

changeNetwork

• changeNetwork(args: { networkId: number }): Promise<{ network: Network | null }>

  Request user to change selected network. Shows an approval window to the user.

  ---

  Required permissions: basic

  Parameters

  • args: { networkId: number }

  Returns Promise<{ network: Network | null }>