contracts.ts

import { ExecuteResult, SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate'
import { fromBech32, toBase64, toBech32 } from '@cosmjs/encoding'
import { Coin, DeliverTxResponse, isDeliverTxFailure } from '@cosmjs/stargate'
import { parseRawLog } from '@cosmjs/stargate/build/logs'
import { toUtf8 } from 'secretjs'

import { ContractVersion } from '@dao-dao/types'
import {
  MsgExecuteContract,
  MsgInstantiateContract,
} from '@dao-dao/types/protobuf/codegen/cosmwasm/wasm/v1/tx'

import { getChainForChainId } from './chain'
import { findEventsAttributeValue } from './client'
import { CHAIN_GAS_MULTIPLIER } from './constants'
import { SecretSigningCosmWasmClient } from './secret'

const CONTRACT_VERSIONS = Object.values(ContractVersion)

// If version is defined, returns it. Otherwise, returns `undefined`.
// Essentially just filters version by its presence in the `ContractVersion`
// enum.
export const parseContractVersion = (
  version: string
): ContractVersion | undefined => CONTRACT_VERSIONS.find((v) => v === version)

export const indexToProposalModulePrefix = (index: number) => {
  index += 1
  let prefix = ''
  while (index > 0) {
    const letterIndex = (index - 1) % 26
    // capital A = 65, Z = 90
    prefix = String.fromCharCode('A'.charCodeAt(0) + letterIndex) + prefix
    index = ((index - letterIndex) / 26) | 0
  }

  return prefix
}

export type SupportedCosmWasmClient =
  | SigningCosmWasmClient
  | SecretSigningCosmWasmClient

/**
 * Instantiate a smart contract from any supported client.
 *
 * This uses our custom instantiate encoder since CosmJS is unreliable due to
 * the SDK version (47+) change that improperly handles the optional admin field
 * as an empty string. The normal signing client `instantiate` function is thus
 * no longer reliable.
 */
export const instantiateSmartContract = async (
  client: SupportedCosmWasmClient | (() => Promise<SupportedCosmWasmClient>),
  sender: string,
  codeId: number,
  label: string,
  msg: object,
  funds?: Coin[],
  admin?: string | null,
  fee = CHAIN_GAS_MULTIPLIER,
  memo: string | undefined = undefined
): Promise<string> => {
  client = typeof client === 'function' ? await client() : client

  if (client instanceof SecretSigningCosmWasmClient) {
    const { contractAddress } = await client.instantiate(
      sender,
      codeId,
      msg,
      label,
      fee,
      {
        funds,
        admin: typeof admin === 'string' ? admin : undefined,
        memo,
      }
    )

    return contractAddress
  } else {
    const result = await client.signAndBroadcast(
      sender,
      [
        {
          typeUrl: MsgInstantiateContract.typeUrl,
          value: MsgInstantiateContract.fromPartial({
            sender,
            admin: admin ?? undefined,
            codeId: BigInt(codeId),
            label,
            msg: toUtf8(JSON.stringify(msg)),
            funds,
          }),
        },
      ],
      fee,
      memo
    )

    if (isDeliverTxFailure(result)) {
      throw new Error(createDeliverTxResponseErrorMessage(result))
    }

    const contractAddress = findEventsAttributeValue(
      result.events,
      'instantiate',
      '_contract_address'
    )

    if (!contractAddress) {
      throw new Error(
        `Contract address not found for TX: ${result.transactionHash}`
      )
    }

    return contractAddress
  }
}

/**
 * Execute a smart contract from any supported client.
 */
export const executeSmartContract = async (
  client: SupportedCosmWasmClient | (() => Promise<SupportedCosmWasmClient>),
  sender: string,
  contractAddress: string,
  msg: object,
  funds?: Coin[],
  fee = CHAIN_GAS_MULTIPLIER,
  memo: string | undefined = undefined
): Promise<ExecuteResult> => {
  client = typeof client === 'function' ? await client() : client

  if (client instanceof SecretSigningCosmWasmClient) {
    return await client.execute(sender, contractAddress, msg, fee, memo, funds)
  } else {
    const result = await client.signAndBroadcast(
      sender,
      [
        {
          typeUrl: MsgExecuteContract.typeUrl,
          value: MsgExecuteContract.fromPartial({
            sender,
            contract: contractAddress,
            msg: toUtf8(JSON.stringify(msg)),
            funds,
          }),
        },
      ],
      fee,
      memo
    )

    if (isDeliverTxFailure(result)) {
      throw new Error(createDeliverTxResponseErrorMessage(result))
    }

    return {
      logs: parseRawLog(result.rawLog),
      height: result.height,
      transactionHash: result.transactionHash,
      events: result.events,
      gasWanted: result.gasWanted,
      gasUsed: result.gasUsed,
    }
  }
}

const createDeliverTxResponseErrorMessage = (result: DeliverTxResponse) =>
  `Error when broadcasting tx ${result.transactionHash} at height ${result.height}. Code: ${result.code}; Raw log: ${result.rawLog}`

/**
 * Convert bech32 address data to address string for the given chain.
 */
export const bech32DataToAddress = (
  chainId: string,
  bech32Bytes: Uint8Array
): string => toBech32(getChainForChainId(chainId).bech32_prefix, bech32Bytes)

/**
 * Convert bech32 address string to base64 string with bech32 data.
 */
export const bech32AddressToBase64 = (bech32Address: string): string =>
  toBase64(fromBech32(bech32Address).data)