import { getNetworkInfo, Network } from "@injectivelabs/networks";
import { ExchangeGrpcClient } from "@injectivelabs/sdk-ts/dist/client/exchange/ExchangeGrpcClient";

(async () => {
  const network = getNetworkInfo(Network.TestnetK8s);
  const injectiveAddress = "inj14au322k9munkmx5wrchz9q30juf5wjgz2cfqku";
  const chainClient = new ExchangeGrpcClient(
    network.sentryGrpcApi
  );

  const balances = await chainClient.bank.fetchBalances(
    injectiveAddress
  );
  const injBalance = balances.find(balace => balance.denom === 'inj')

  console.log(injBalance);
})();

import { getNetworkInfo, Network } from "@injectivelabs/networks";
import { ChainGrpcClient } from "@injectivelabs/sdk-ts/dist/client/chain/ChainGrpcClient";

(async () => {
  const network = getNetworkInfo(Network.TestnetK8s);
  const subaccountId = "0xaf79152ac5df276d9a8e1e2e22822f9713474902000000000000000000000000";
  const exchangeClient = new ChainGrpcClient(
    network.exchangeApi
  );

  const subaccountBalancesList = await exchangeClient.account.fetchSubaccountBalancesList(
    subaccountId
  );

  console.log(subaccountBalancesList);
})();

// Importing only the needed API
import { ChainClient, Network } from '@injectivelabs/sdk-ts'

const network = Network.testnet()
const injectiveAddress = 'inj1hkhdaj2a2clmq5jq6mspsggqs32vynpk228q3r'
const denom = 'inj'
const bankApi = new ChainClient.BankApi(network.sentryGrpcApi)
console.log(await bankApi.balance({ injectiveAddress, denom }))

// Using the client
import { ExchangeClient, Network } from '@injectivelabs/sdk-ts'

const network = Network.testnet()
const exchangeGrpcClient = new ExchangeClient.GrpcClient(network.exchangeApi)
console.log(await exchangeGrpcClient.derivativesApi.markets())

// Importing only the needed API
import { ExchangeClient, Network } from '@injectivelabs/sdk-ts'

const network = Network.testnet()
const derivativesApi = new ExchangeClient.DerivativesApi(network.exchangeApi)
console.log(await derivativesApi.markets())

import { getNetworkInfo, Network } from "@injectivelabs/networks";
import {
  AuctionCore,
  ChainClient,
  PrivateKey,
  BaseAccount,
  TxInjective,
  TxService,
} from "@injectivelabs/sdk-ts";
import { BigNumberInBase } from "@injectivelabs/utils";

/** MsgBid Example */
(async () => {
  const network = getNetworkInfo(Network.TestnetK8s);
  const privateKey = PrivateKey.fromPrivateKey(
    "f9db9bf330e23cb7839039e944adef6e9df447b90b503d5b4464c90bea9022f3"
  );
  const injectiveAddress = privateKey.toBech32();
  console.log(injectiveAddress, privateKey.toHex());

  /** Account Details **/
  const accountDetails = await new ChainClient.AuthRestApi(
    network.sentryHttpApi
  ).account(injectiveAddress);
  const baseAccount = BaseAccount.fromRestApi(accountDetails);

  /** Prepare the Message */
  const auctionModuleState = await new ChainClient.AuctionApi(
    network.sentryGrpcApi
  ).moduleState();
  const latestRound = auctionModuleState.getState()?.getAuctionRound();
  const round = latestRound || 1;
  const bid = 1; /** 100 INJ */
  const amount = {
    amount: new BigNumberInBase(bid).toWei().toFixed(),
    denom: "inj",
  };
  const msg = new AuctionCore.MsgBid({
    round,
    amount,
    injectiveAddress,
  });

  /** Prepare the Transaction **/
  const txInjective = new TxInjective({
    baseAccount,
    msgs: [msg],
    chainId: network.chainId,
    address: injectiveAddress,
  });

  /** Sign transaction */
  const signature = await privateKey.sign(txInjective.signBytes);
  const signedTxInjective = txInjective.withSignature(signature);

  /** Calculate hash of the transaction */
  console.log(`Transaction Hash: ${signedTxInjective.getTxHash()}`);

  const txService = new TxService({
    txInjective: signedTxInjective,
    endpoint: network.sentryGrpcApi,
  });

  /** Simulate transaction */
  const simulationResponse = await txService.simulate();
  console.log(
    `Transaction simulation response: ${JSON.stringify(
      simulationResponse.gasInfo
    )}`
  );

  /** Broadcast transaction */
  const txResponse = await txService.broadcast();
  console.log(
    `Broadcasted transaction hash: ${JSON.stringify(txResponse.txhash)}`
  );
})();

import { getNetworkInfo, Network } from "@injectivelabs/networks";
import { protoObjectToJson } from "@injectivelabs/sdk-ts";
import { ExchangeGrpcStreamClient } from "@injectivelabs/sdk-ts/dist/client/exchange/ExchangeGrpcStreamClient";

(async () => {
  const network = getNetworkInfo(Network.TestnetK8s);

  const subaccountId =
    "0xaf79152ac5df276d9a8e1e2e22822f9713474902000000000000000000000000";

  const exchangeClient = new ExchangeGrpcStreamClient(
    network.exchangeApi
  );

  await exchangeClient.account.streamSubaccountBalance({
    subaccountId,
    callback: (subaccountBalance) => {
      console.log(protoObjectToJson(subaccountBalance));
    },
    onEndCallback: (status) => {
      console.log("Stream has ended with status: " + status);
    },
  });
})();