Class EVM

chainId

connected

contracts

isEIP1559

name

provider

rpc_url

signer

wallet

connect

• connect(chainId?, isEIP1559?): Promise<boolean>

• Connects to the EVM network

  Parameters

  • OptionalchainId: number

    (Optional) The chainId of this network
  • OptionalisEIP1559: boolean

    (Optional) Whether this network uses EIP-1559

  Returns Promise<boolean>

  A boolean indicating whether the connection was successful

  When parameters are not provided, they are automatically inferred from the network.

connectWallet

• connectWallet(privateKey): Promise<Wallet>

• Connects to a wallet using a private key

  Parameters

  • privateKey: string

    The private key of the wallet

  Returns Promise<Wallet>

  The wallet object

createRawTransaction

• createRawTransaction(tx_data): Promise<any>

• Parameters

  • tx_data: any

  Returns Promise<any>

disconnect

• disconnect(): Promise<boolean>

• Disconnects from the RPC provider and the wallet

  Returns Promise<boolean>

  A boolean indicating if the disconnection was successful

getAddress

• getAddress(): string

• Returns the address of the connected wallet

  Returns string

getBalance

• getBalance(address): Promise<string>

• Gets the balance of a wallet

  Parameters

  • address: string

    The wallet address

  Returns Promise<string>

  The balance of the wallet as a string

getContractInstance

• getContractInstance(address, abi): Promise<Contract>

• Parameters

  • address: string
  • abi: string

  Returns Promise<Contract>

getEmptyTransaction

• getEmptyTransaction(): Promise<{
      chainId: number;
      gasLimit: number;
      maxFeePerGas: bigint;
      maxPriorityFeePerGas: bigint;
      type: number;
  } | {
      chainId: number;
      gasLimit: number;
      gasPrice: bigint;
  }>

• Creates a skeleton transaction

  Returns Promise<{
      chainId: number;
      gasLimit: number;
      maxFeePerGas: bigint;
      maxPriorityFeePerGas: bigint;
      type: number;
  } | {
      chainId: number;
      gasLimit: number;
      gasPrice: bigint;
  }>

getTokenBalance

• getTokenBalance(contract_address, address): Promise<{
      balance: string;
      decimals: number;
      name: string;
      symbol: string;
  }>

• Get the balance of a token

  Parameters

  • contract_address: string

    The address of the token contract
  • address: string

    The address of the wallet

  Returns Promise<{
      balance: string;
      decimals: number;
      name: string;
      symbol: string;
  }>

  The balance of the token

isAddress

• isAddress(address): boolean

• Check if an address is valid

  Parameters

  • address: string

    The address to check

  Returns boolean

  A boolean indicating whether the address is valid

listenForAllEvents

• listenForAllEvents(contract, abi): Promise<any>

• Parameters

  • contract: string
  • abi: any[]

  Returns Promise<any>

listenForEvent

• listenForEvent(event, contract, abi): Promise<any>

• Parameters

  • event: string
  • contract: string
  • abi: any[]

  Returns Promise<any>

prepareBaseTxWithType

• prepareBaseTxWithType(): Promise<{
      chainId: number;
      gasLimit: number;
      maxFeePerGas: bigint;
      maxPriorityFeePerGas: bigint;
      type: number;
  } | {
      chainId: number;
      gasLimit: number;
      gasPrice: bigint;
  }>

• Returns Promise<{
      chainId: number;
      gasLimit: number;
      maxFeePerGas: bigint;
      maxPriorityFeePerGas: bigint;
      type: number;
  } | {
      chainId: number;
      gasLimit: number;
      gasPrice: bigint;
  }>

preparePay

• preparePay(address, amount, options?): Promise<string>
• Alias

  Creates a signed transaction to transfer default chain currency

  Parameters

  • address: string
  • amount: string

    The amount to transfer
  • Optionaloptions: {
        gasLimit?: number;
    }

    Options

    • OptionalgasLimit?: number

  Returns Promise<string>

  The signed transaction

  prepareTransfer

preparePays

• preparePays(payments, options?): Promise<string[]>

• Creates a list of signed transactions to transfer default chain currency

  Parameters

  • payments: IPayOptions[]

    A list of transfers to prepare
  • Optionaloptions: {
        gasLimit?: number;
    }

    Options

    • OptionalgasLimit?: number

  Returns Promise<string[]>

  An ordered list of signed transactions

prepareTransfer

• prepareTransfer<T, Options>(this, receiver, amount, options?): Promise<Awaited<ReturnType<T["preparePays"]>>[number]>

• Creates a signed transaction to transfer default chain currency

  Type Parameters

  • T extends DefaultChain
  • Options extends {}

  Parameters

  • this: T
  • receiver: string

    The receiver's address
  • amount: string

    The amount to transfer
  • Optionaloptions: Options

    Options

  Returns Promise<Awaited<ReturnType<T["preparePays"]>>[number]>

  The signed transaction

prepareTransfers

• prepareTransfers<T, Options>(this, payments, options?): Promise<Awaited<ReturnType<T["preparePays"]>>>

• Creatthis.provider = new JsonRpcProvider(this.rpc_url)es a list of signed transactions to transfer default chain currency

  Type Parameters

  • T extends DefaultChain
  • Options extends {}

  Parameters

  • this: T
  • payments: IPayOptions[]

    A list of transfers to prepare
  • Optionaloptions: Options

    Options

  Returns Promise<Awaited<ReturnType<T["preparePays"]>>>

  An ordered list of signed transactions

readFromContract

• readFromContract(contract_instance, function_name, args): Promise<any>

• Parameters

  • contract_instance: Contract
  • function_name: string
  • args: any

  Returns Promise<any>

setRpc

• setRpc(rpc_url): void

• Sets the RPC URL only. Use await instance.connect() to connect to the rpc provider

  Parameters

  • rpc_url: string

  Returns void

signMessage

• signMessage(message, options?): Promise<string>

• Signs a message using the connected wallet

  Parameters

  • message: string

    The message to sign
  • Optionaloptions: {
        privateKey?: string;
    }

    Options

    • OptionalprivateKey?: string

  Returns Promise<string>

  The signed message

signTransaction

• signTransaction(transaction, options?): Promise<string>

• Signs a transaction using the connected wallet

  Parameters

  • transaction: TransactionRequest
  • Optionaloptions: {
        privateKey?: string;
    }

    Options

    • OptionalprivateKey?: string

  Returns Promise<string>

  The signed transaction

signTransactions

• signTransactions(transactions, options?): Promise<string[]>

• Signs a list of transactions using the connected wallet. The transaction nonce is incremented for each transaction in order of appearance.

  Parameters

  • transactions: TransactionRequest[]

    A list of transactions to sign
  • Optionaloptions: {
        privateKey?: string;
    }

    Options

    • OptionalprivateKey?: string

  Returns Promise<string[]>

verifyMessage

• verifyMessage(message, signature, publicKey): Promise<boolean>

• Verifies a message using the connected wallet

  Parameters

  • message: string

    The message to verify
  • signature: string

    The signature to verify
  • publicKey: string

  Returns Promise<boolean>

  A boolean indicating if the message was verified

waitForReceipt

• waitForReceipt(tx_hash): Promise<any>

• Parameters

  • tx_hash: string

  Returns Promise<any>

writeToContract

• writeToContract(contract_instance, function_name, args, options?): Promise<string>

• Parameters

  • contract_instance: Contract
  • function_name: string
  • args: any[]
  • Optionaloptions: {
        gasLimit?: number;
        value?: string;
    }

    • OptionalgasLimit?: number

    • Optionalvalue?: string

  Returns Promise<string>

Staticcreate

• create<T>(this, rpc_url?): Promise<T>

• Creates a new instance of this sdk

  Type Parameters

  • T extends DefaultChain

  Parameters

  • this: (new (rpc_url: string) => T)
    • • new (rpc_url): T

      • Parameters

        • rpc_url: string

        Returns T

  • rpc_url: string = ""

    The RPC URL

  Returns Promise<T>

  The sdk instance connected to the RPC provider