Class SigningCosmWasmClient

Hierarchy (view full)

Constructors

constructor

Properties

broadcastPollIntervalMs broadcastTimeoutMs registry

Methods

broadcastTx broadcastTxSync clearAdmin delegateTokens disconnect execute executeMultiple forceGetQueryClient forceGetTmClient getAccount getBalance getBlock getChainId getCodeDetails getCodes getContract getContractCodeHistory getContracts getContractsByCreator getHeight getQueryClient getSequence getTmClient getTx instantiate instantiate2 migrate queryContractRaw queryContractSmart searchTx sendTokens sign signAndBroadcast signAndBroadcastSync simulate undelegateTokens updateAdmin upload withdrawRewards connect connectWithSigner create createWithSigner offline

Constructors

Protected constructor

Properties

Readonly broadcastPollIntervalMs

broadcastPollIntervalMs: undefined | number

Readonly broadcastTimeoutMs

broadcastTimeoutMs: undefined | number

Readonly registry

registry: Registry

Methods

broadcastTx

  • broadcastTx(tx, timeoutMs?, pollIntervalMs?): Promise<DeliverTxResponse>

  • Broadcasts a signed transaction to the network and monitors its inclusion in a block.

    If broadcasting is rejected by the node for some reason (e.g. because of a CheckTx failure), an error is thrown.

    If the transaction is not included in a block before the provided timeout, this errors with a TimeoutError.

    If the transaction is included in a block, a DeliverTxResponse is returned. The caller then usually needs to check for execution success or failure.

    Parameters

    • tx: Uint8Array
    • timeoutMs: number = 60_000
    • pollIntervalMs: number = 3_000

    Returns Promise<DeliverTxResponse>

broadcastTxSync

  • broadcastTxSync(tx): Promise<string>

  • Broadcasts a signed transaction to the network without monitoring it.

    If broadcasting is rejected by the node for some reason (e.g. because of a CheckTx failure), an error is thrown.

    If the transaction is broadcasted, a string containing the hash of the transaction is returned. The caller then usually needs to check if the transaction was included in a block and was successful.

    Parameters

    • tx: Uint8Array

    Returns Promise<string>

    Returns the hash of the transaction

clearAdmin

  • clearAdmin(senderAddress, contractAddress, fee, memo?): Promise<ChangeAdminResult>

  • Parameters

    • senderAddress: string
    • contractAddress: string
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<ChangeAdminResult>

delegateTokens

  • delegateTokens(delegatorAddress, validatorAddress, amount, fee, memo?): Promise<DeliverTxResponse>

  • Parameters

    • delegatorAddress: string
    • validatorAddress: string
    • amount: Coin
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<DeliverTxResponse>

disconnect

execute

  • execute(senderAddress, contractAddress, msg, fee, memo?, funds?): Promise<ExecuteResult>

  • Parameters

    • senderAddress: string
    • contractAddress: string
    • msg: any
    • fee: number | "auto" | StdFee
    • memo: string = ""
    • Optional funds: readonly Coin[]

    Returns Promise<ExecuteResult>

executeMultiple

  • executeMultiple(senderAddress, instructions, fee, memo?): Promise<ExecuteResult>

  • Like execute but allows executing multiple messages in one transaction.

    Parameters

    Returns Promise<ExecuteResult>

Protected forceGetQueryClient

Protected forceGetTmClient

getAccount

getBalance

  • getBalance(address, searchDenom): Promise<Coin>

  • Parameters

    • address: string
    • searchDenom: string

    Returns Promise<Coin>

getBlock

  • getBlock(height?): Promise<Block>

  • Parameters

    • Optional height: number

    Returns Promise<Block>

getChainId

  • getChainId(): Promise<string>

  • Returns Promise<string>

getCodeDetails

getCodes

  • getCodes(): Promise<readonly Code[]>

  • getCodes() returns all codes and is just looping through all pagination pages.

    This is potentially inefficient and advanced apps should consider creating their own query client to handle pagination together with the app's screens.

    Returns Promise<readonly Code[]>

getContract

  • getContract(address): Promise<Contract>

  • Throws an error if no contract was found at the address

    Parameters

    • address: string

    Returns Promise<Contract>

getContractCodeHistory

getContracts

  • getContracts(codeId): Promise<readonly string[]>

  • getContracts() returns all contract instances for one code and is just looping through all pagination pages.

    This is potentially inefficient and advanced apps should consider creating their own query client to handle pagination together with the app's screens.

    Parameters

    • codeId: number

    Returns Promise<readonly string[]>

getContractsByCreator

  • getContractsByCreator(creator): Promise<string[]>

  • Returns a list of contract addresses created by the given creator. This just loops through all pagination pages.

    Parameters

    • creator: string

    Returns Promise<string[]>

getHeight

  • getHeight(): Promise<number>

  • Returns Promise<number>

Protected getQueryClient

getSequence

Protected getTmClient

  • getTmClient(): undefined | TendermintClient

  • Returns undefined | TendermintClient

getTx

instantiate

  • instantiate(senderAddress, codeId, msg, label, fee, options?): Promise<InstantiateResult>

  • Parameters

    Returns Promise<InstantiateResult>

instantiate2

  • instantiate2(senderAddress, codeId, salt, msg, label, fee, options?): Promise<InstantiateResult>

  • Parameters

    • senderAddress: string
    • codeId: number
    • salt: Uint8Array
    • msg: any
    • label: string
    • fee: number | "auto" | StdFee
    • options: InstantiateOptions = {}

    Returns Promise<InstantiateResult>

migrate

  • migrate(senderAddress, contractAddress, codeId, migrateMsg, fee, memo?): Promise<MigrateResult>

  • Parameters

    • senderAddress: string
    • contractAddress: string
    • codeId: number
    • migrateMsg: any
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<MigrateResult>

queryContractRaw

  • queryContractRaw(address, key): Promise<null | Uint8Array>

  • Returns the data at the key if present (raw contract dependent storage data) or null if no data at this key.

    Promise is rejected when contract does not exist.

    Parameters

    • address: string
    • key: Uint8Array

    Returns Promise<null | Uint8Array>

queryContractSmart

  • queryContractSmart(address, queryMsg): Promise<any>

  • Makes a smart query on the contract, returns the parsed JSON document.

    Promise is rejected when contract does not exist. Promise is rejected for invalid query format. Promise is rejected for invalid response format.

    Parameters

    • address: string
    • queryMsg: any

    Returns Promise<any>

searchTx

sendTokens

  • sendTokens(senderAddress, recipientAddress, amount, fee, memo?): Promise<DeliverTxResponse>

  • Parameters

    • senderAddress: string
    • recipientAddress: string
    • amount: readonly Coin[]
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<DeliverTxResponse>

sign

  • sign(signerAddress, messages, fee, memo, explicitSignerData?): Promise<TxRaw>

  • Parameters

    • signerAddress: string
    • messages: readonly EncodeObject[]
    • fee: StdFee
    • memo: string
    • Optional explicitSignerData: SignerData

    Returns Promise<TxRaw>

signAndBroadcast

  • signAndBroadcast(signerAddress, messages, fee, memo?): Promise<DeliverTxResponse>

  • Creates a transaction with the given messages, fee and memo. Then signs and broadcasts the transaction.

    Parameters

    • signerAddress: string

      The address that will sign transactions using this instance. The signer must be able to sign with this address.

    • messages: readonly EncodeObject[]
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<DeliverTxResponse>

signAndBroadcastSync

  • signAndBroadcastSync(signerAddress, messages, fee, memo?): Promise<string>

  • Creates a transaction with the given messages, fee and memo. Then signs and broadcasts the transaction.

    This method is useful if you want to send a transaction in broadcast, without waiting for it to be placed inside a block, because for example I would like to receive the hash to later track the transaction with another tool.

    Parameters

    • signerAddress: string

      The address that will sign transactions using this instance. The signer must be able to sign with this address.

    • messages: readonly EncodeObject[]
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<string>

    Returns the hash of the transaction

simulate

  • simulate(signerAddress, messages, memo): Promise<number>

  • Parameters

    • signerAddress: string
    • messages: readonly EncodeObject[]
    • memo: undefined | string

    Returns Promise<number>

undelegateTokens

  • undelegateTokens(delegatorAddress, validatorAddress, amount, fee, memo?): Promise<DeliverTxResponse>

  • Parameters

    • delegatorAddress: string
    • validatorAddress: string
    • amount: Coin
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<DeliverTxResponse>

updateAdmin

  • updateAdmin(senderAddress, contractAddress, newAdmin, fee, memo?): Promise<ChangeAdminResult>

  • Parameters

    • senderAddress: string
    • contractAddress: string
    • newAdmin: string
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<ChangeAdminResult>

upload

  • upload(senderAddress, wasmCode, fee, memo?, instantiatePermission?): Promise<UploadResult>

  • Uploads code and returns a receipt, including the code ID

    Parameters

    • senderAddress: string
    • wasmCode: Uint8Array
    • fee: number | "auto" | StdFee
    • memo: string = ""
    • Optional instantiatePermission: AccessConfig

    Returns Promise<UploadResult>

withdrawRewards

  • withdrawRewards(delegatorAddress, validatorAddress, fee, memo?): Promise<DeliverTxResponse>

  • Parameters

    • delegatorAddress: string
    • validatorAddress: string
    • fee: number | "auto" | StdFee
    • memo: string = ""

    Returns Promise<DeliverTxResponse>

Static connect

  • connect(endpoint): Promise<CosmWasmClient>

  • Creates an instance by connecting to the given Tendermint RPC endpoint.

    This uses auto-detection to decide between a Tendermint 0.37 and 0.34 client. To set the Tendermint client explicitly, use create.

    Parameters

    Returns Promise<CosmWasmClient>

Static connectWithSigner

  • connectWithSigner(endpoint, signer, options?): Promise<SigningCosmWasmClient>

  • Creates an instance by connecting to the given Tendermint RPC endpoint.

    This uses auto-detection to decide between a Tendermint 0.37 and 0.34 client. To set the Tendermint client explicitly, use createWithSigner.

    Parameters

    Returns Promise<SigningCosmWasmClient>

Static create

  • create(tmClient): Promise<CosmWasmClient>

  • Creates an instance from a manually created Tendermint client. Use this to use Tendermint37Client instead of Tendermint34Client.

    Parameters

    • tmClient: TendermintClient

    Returns Promise<CosmWasmClient>

Static createWithSigner

Static offline

  • offline(signer, options?): Promise<SigningCosmWasmClient>

  • Creates a client in offline mode.

    This should only be used in niche cases where you know exactly what you're doing, e.g. when building an offline signing application.

    When you try to use online functionality with such a signer, an exception will be raised.

    Parameters

    Returns Promise<SigningCosmWasmClient>

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc