ArchwayClient

Class

A client to interact with the Archway chain.

export default class ArchwayClient extends BaseChainClient {
  public signingClient?: SigningArchwayClient;
  public queryClient?: CosmWasmClient;
  public gasPrice?: GasPrice;

Name	Type	Descriptions
signingClient	SigningArchwayClient	The client used to sign any transactions broadcast to the chain.
queryClient	CosmWasmClient	The client used to query the chain.
gasPrice	GasPrice	Optional configurations for the gas prices to use.

Methods

connect

Connects to the given chain. Assigns all clients used within the chain client, if a signer is provided a signing client is assigned.

async connect(
    endpoint: string,
    signer?: OfflineSigner,
    options?: SigningCosmWasmClientOptions
  ): Promise<void> {
    delete this.signingClient;
    delete this.queryClient;
    this.gasPrice = options?.gasPrice;

    this.queryClient = await CosmWasmClient.connect(endpoint);
    if (signer) {
      this.signingClient = await SigningArchwayClient.connectWithSigner(
        endpoint,
        signer,
        {
          gasAdjustment: 1.4,
        }
      );

      const [account] = await signer.getAccounts();
      this.signer = account.address;
    }
  }

Name	Type	Description
endpoint	string	The endpoint of the chain to connect to.
signer	OfflineSigner	Optional signer used to sign the messages.
options	SigningCosmWasmClientOptions	Optional field to set the client options.

disconnect

Disconnects the assigned clients.

async disconnect(): Promise<void> {
    if (this.signingClient) this.signingClient.disconnect();
    if (this.queryClient) this.queryClient.disconnect();

    delete this.signingClient;
    delete this.queryClient;
    this.signer = "";
    delete this.gasPrice;
  }

sign

Signs a given message with the connected signer.

async sign(messages: EncodeObject[], fee: StdFee, memo = ""): Promise<TxRaw> {
    this.preMessage(true);
    return await this.signingClient!.sign(this.signer, messages, fee, memo);
  }

Name	Type	Description
messages	EncodeObject[]	The messages to sign.
fee	StdFee	The fee to pay for signing.
memo	string	Defaults to an empty string.

broadcast

Broadcasts a given transaction to the connected client.

async broadcast(tx: TxRaw): ReturnType<ChainClient["broadcast"]> {
    this.preMessage(true);
    const txBytes = TxRaw.encode(tx).finish();
    return await this.signingClient!.broadcastTx(txBytes);
  }

Name	Type	Description
tx	TxRaw	The transaction to broadcast.

TxRaw

TxRaw is a variant of Tx that pins the signer's exact binary representationof body and auth_info. This is used for signing, broadcasting and verification. The binary serialize(tx: TxRaw) is stored in Tendermint and the hash sha256(serialize(tx: TxRaw)) becomes the "txhash", commonly used as the transaction ID.

export interface TxRaw {
    /**
     * body_bytes is a protobuf serialization of a TxBody that matches the
     * representation in SignDoc.
     */
    bodyBytes: Uint8Array;
    /**
     * auth_info_bytes is a protobuf serialization of an AuthInfo that matches the
     * representation in SignDoc.
     */
    authInfoBytes: Uint8Array;
    /**
     * signatures is a list of signatures that matches the length and order of
     * AuthInfo's signer_infos to allow connecting signature meta information like
     * public key and signing mode by position.
     */
    signatures: Uint8Array[];
}

signAndBroadcast

Signs a given message before broadcasting it to the connected chain.

  async signAndBroadcast(
    messages: EncodeObject[],
    fee: Fee = "auto",
    memo?: string | undefined
  ): Promise<DeliverTxResponse> {
    this.preMessage(true);

    return await this.signingClient!.signAndBroadcast(
      this.signer,
      messages,
      fee,
      memo
    );
  }

Name	Type	Description
messages	EncodeObject[]	The messages to sign and broadcast.
fee	Fee	The fee to pay for signing and broadcasting the message. Defaults to auto if not specified.
memo	string or undefined	An optional memo to attach to the transaction.

EncodeObject

export interface EncodeObject {
    readonly typeUrl: string;
    readonly value: any;
}

Fee

export type Fee = number | StdFee | "auto";

simulateMulti

Simulates all given messages and returns a gas fee estimate.

 async simulateMulti(
    messages: EncodeObject[],
    _fee: Fee = "auto",
    memo?: string | undefined
  ): Promise<number> {
    this.preMessage();
    return this.signingClient!.simulate(this.signer, messages, memo);
  }

Name	Type	Description
messages	EncodeObject[]	The messages to simulate.
_fee	Fee	The fee to pay. Defaults to auto if not specified.
memo	string or undefined	Optional memo to attach to the transaction.

simulate

Simulates the given message and returns a gas fee estimate.

  async simulate(
    message: EncodeObject,
    _fee?: Fee | undefined,
    memo?: string | undefined
  ): Promise<number> {
    this.preMessage();
    return this.signingClient!.simulate(this.signer, [message], memo);
  }

Name	Type	Description
message	EncodeObject	The message to simulate.
_fee	Fee	Optional fee attached to the message.
memo	string or undefined	Optional memo to attach to the transaction.

execute

Executes a message on the specified contract.

 async execute(
    contractAddress: string,
    msg: Msg,
    _fee?: Fee | undefined,
    memo?: string | undefined,
    funds?: readonly Coin[] | undefined
  ): Promise<ExecuteResult> {
    this.preMessage(true);
    return await this.signingClient!.execute(
      this.signer,
      contractAddress,
      msg,
      "auto",
      memo,
      funds
    );
  }

Name	Type	Description
contractAddress	string	The contract address to execute on.
msg	Msg	The execute message.
_fee	Fee	Optional fee. Defaults to auto
memo	string or undefined	Optional memo to attach to the transaction.
funds	Coin[] or udefined	Optional funds to attach along with the message.

Msg

export type Msg = Record<string, unknown>;

simulateExecute

Simulates an execute message and returns a gas fee estimate.

  async simulateExecute(
    address: string,
    msg: Msg,
    funds: Coin[],
    _fee?: Fee,
    memo?: string | undefined
  ) {
    const message = this.encodeExecuteMsg(address, msg, funds);
    return this.simulate(message, undefined, memo);
  }

Name	Type	Description
address	string	The contract address you are executing on.
msg	Msg	The execute message to simulate.
funds	Coin[]	The funds attached along with the message.
_fee	Fee	Optional fee for executing the message.
memo	string or undefined	Optional memo to add to the transaction.

upload

Uploads given contract code (Uint8Array) to the chain.

 async upload(
    code: Uint8Array,
    fee: Fee = "auto",
    memo?: string | undefined
  ): Promise<UploadResult> {
    this.preMessage();
    const result = await this.signingClient!.upload(
      this.signer,
      code,
      fee,
      memo
    );
    return { ...result };
  }

Name	Type	Description
code	Uint8Array	The wasm binary code to upload to the connected client.
fee	Fee	Optional Fee. Defaults to "auto".
memo	string or undefined	Optional memo to add to the transaction.

simulateUpload

Simulate an upload message and returns a gas fee estimate.

async simulateUpload(
    code: Uint8Array,
    _fee?: Fee | undefined,
    memo?: string | undefined
  ): Promise<number | undefined> {
    const message = this.encodeUploadMessage(code);
    return this.simulate(message, undefined, memo);
  }

Name	Type	Description
code	Uint8Array	The wasm binary code to simulate uploading.
_fee	Fee	Fee to pay for uploading.
memo	string or undefined	Optional memo to add to the transaction.

instantiate

Instantiates a contract with the given code id using the provided instantiate message.

 async instantiate(
    codeId: number,
    msg: Msg,
    label: string,
    fee: Fee = "auto",
    options?: InstantiateOptions
  ): Promise<InstantiateResult> {
    this.preMessage(true);
    return this.signingClient!.instantiate(
      this.signer,
      codeId,
      msg,
      label,
      fee,
      options
    );
  }

Name	Type	Description
codeId	number	The code Id of the contract to instantiate.
msg	Msg	The instantiation message.
label	string	A label for the instantiation. Can be any string such as " instantiating a CW721" or "my_label" ect...
fee	Fee	Fee to pay for instantiation. Defaults to auto.
options	InstantiateOptions	The options of an .instantiate() call. All properties are optional.

simulateInstantiate

Simulates an instantiation message and returns a gas fee estimate.

 async simulateInstantiate(
    codeId: number,
    msg: Msg,
    label: string,
    fee?: StdFee,
    options?: InstantiateOptions
  ): Promise<number | undefined> {
    const message = this.encodeInstantiateMsg(codeId, msg, label);
    return this.simulate(message, fee, options?.memo);
  }

Name	Type	Description
codeId	number	The code Id of the contract to simulate instantiating.
msg	Msg	The instantiation message.
label	string	A label for the instantiation. Can be any string such as " instantiating a CW721" or "my_label" ect...
fee	Fee	Fee to pay for instantiation. Defaults to auto.
options	InstantiateOptions	The options of an .instantiate() call. All properties are optional.

migrate

Migrates a contract to a given code id.

async migrate(
    contractAddress: string,
    codeId: number,
    msg: Msg,
    fee: Fee = "auto",
    memo?: string | undefined
  ): Promise<MigrateResult> {
    this.preMessage(true);
    return this.signingClient!.migrate(
      this.signer,
      contractAddress,
      codeId,
      msg,
      fee,
      memo
    );
  }

Name	Type	Description
contractAddress	string	The address of the contract that you want to migrate.
codeId	number	The code Id to migrate to.
msg	Msg	The migrate message.
fee	Fee	The fee to pay for the migration.
memo	string or undefined	Optional memo to attach to the transaction.

simulateMigrate

Simulates a migrate message for a given contract address, code id and migrate message and returns a gas estimate.

async simulateMigrate(
    contractAddress: string,
    codeId: number,
    msg: Msg,
    fee?: Fee | undefined,
    memo?: string | undefined
  ): Promise<number | undefined> {
    const message = this.encodeMigrateMessage(contractAddress, codeId, msg);
    return this.simulate(message, fee, memo);
  }

Name	Type	Description
contractAddress	string	The contract address that you want to migrate.
codeId	number	The code Id to migrate to.
msg	Msg	The migrate message.
fee	Fee	Optional fee to pay to send the funds.
memo	string	Optional memo to attach to the transaction.

sendTokens

Sends tokens from the signing address to the provided receiving address.

  async sendTokens(
    receivingAddress: string,
    amount: readonly Coin[],
    fee: Fee = "auto",
    memo?: string | undefined
  ): Promise<any> {
    return this.signingClient?.sendTokens(
      this.signer,
      receivingAddress,
      amount,
      fee,
      memo
    );
  }
}

Name	Type	Description
receivingAddress	string	The address to receive the tokens.
amount	Coin []	The funds to send.
fee	Fee	Optional fee to pay to send the funds.
memo	string	Optional memo to attach to the transaction.