wormhole/wormchain/contracts/tools/test_wormchain.ts

import "dotenv/config";
import * as os from "os"
import { SigningCosmWasmClient, toBinary } from "@cosmjs/cosmwasm-stargate";
import { GasPrice } from "@cosmjs/stargate"
import { fromBase64 } from "cosmwasm";
import { Secp256k1HdWallet } from "@cosmjs/amino";

import { zeroPad } from "ethers/lib/utils.js";
import { keccak256 } from "@cosmjs/crypto"

import * as elliptic from "elliptic"
import { concatArrays, encodeUint8 } from "./utils";

import * as devnetConsts from "./devnet-consts.json"


function signBinary(key: elliptic.ec.KeyPair, binary: string): Uint8Array {
  // base64 string to Uint8Array,
  // so we have bytes to work with for signing, though not sure 100% that's correct.
  const bytes = fromBase64(binary);

  // create the "digest" for signing.
  // The contract will calculate the digest of the "data",
  // then use that with the signature to ec recover the publickey that signed.
  const digest = keccak256(keccak256(bytes));

  // sign the digest
  const signature = key.sign(digest, { canonical: true });

  // create 65 byte signature (64 + 1)
  const signedParts = [
    zeroPad(signature.r.toBuffer(), 32),
    zeroPad(signature.s.toBuffer(), 32),
    encodeUint8(signature.recoveryParam || 0),
  ];

  // combine parts to be Uint8Array with length 65
  const signed = concatArrays(signedParts);

  return signed
}


async function main() {

  /* Set up cosmos client & wallet */

  const WORMCHAIN_ID = 3104

  let host = devnetConsts.chains[3104].tendermintUrlLocal
  if (os.hostname().includes("wormchain-deploy")) {
    // running in tilt devnet
    host = devnetConsts.chains[3104].tendermintUrlTilt
  }
  const denom = devnetConsts.chains[WORMCHAIN_ID].addresses.native.denom
  const mnemonic = devnetConsts.chains[WORMCHAIN_ID].accounts.wormchainNodeOfGuardian0.mnemonic
  const addressPrefix = "wormhole"
  const signerPk = devnetConsts.devnetGuardians[0].private
  const accountingAddress = devnetConsts.chains[WORMCHAIN_ID].contracts.accountingNativeAddress

  const w = await Secp256k1HdWallet.fromMnemonic(mnemonic, { prefix: addressPrefix })

  const gas = GasPrice.fromString(`0${denom}`)
  let cwc = await SigningCosmWasmClient.connectWithSigner(host, w, { prefix: addressPrefix, gasPrice: gas })

  // there is no danger here, just several Cosmos chains in devnet, so check for config issues
  let id = await cwc.getChainId()
  if (id !== "wormchain") {
    throw new Error(`Wormchain CosmWasmClient connection produced an unexpected chainID: ${id}`)
  }

  const signers = await w.getAccounts()
  const signer = signers[0].address
  console.log("wormchain wallet pubkey: ", signer)

  const nativeBalance = await cwc.getBalance(signer, denom)
  console.log("nativeBalance ", nativeBalance.amount)

  const utestBalance = await cwc.getBalance(signer, "utest")
  console.log("utest balance ", utestBalance.amount)


  // create key for guardian0
  const ec = new elliptic.ec("secp256k1");
  // create key from the devnet guardian0's private key
  const key = ec.keyFromPrivate(Buffer.from(signerPk, "hex"));


  // Test empty observation

  // object to json string, then to base64 (serde binary)
  const arrayBinaryString = toBinary([]);

  // combine parts to be Uint8Array with length 65
  const signedEmptyArray = signBinary(key, arrayBinaryString)

  const observeEmptyArray = {
    submit_observations: {
      observations: arrayBinaryString,
      guardian_set_index: 0,
      signature: {
        index: 0,
        signature: Array.from(signedEmptyArray),
      },
    },
  };

  let emptyArrayObsRes = await cwc.execute(signer, accountingAddress, observeEmptyArray, "auto");
  console.log(`emptyArrayObsRes.transactionHash: ${emptyArrayObsRes.transactionHash}`);


  // Test (fake) observation
  const emitter_address = "0000000000000000000000000290fb167208af455bb137780163b7b7a9a10c16"
  const observations = [
    {
      emitter_chain: 2,
      emitter_address: emitter_address,
      sequence: 2,
      nonce: 1,
      consistency_level: 0,
      timestamp: 1,
      payload:
        Buffer.from("030000000000000000000000000000000000000000000000000000000005f5e1000000000000000000000000002d8be6bf0baa74e0a907016679cae9190e80dd0a0002000000000000000000000000c10820983f33456ce7beb3a046f5a83fa34f027d0c2000000000000000000000000000000000000000000000000000000000000f4240", "hex").toString("base64"),

      tx_hash:
        Buffer.from("9fc68fb0ee735d45c9074a20adef1747b0593803f33b9f3f2252c8e2df567f41", "hex").toString("base64")
    },
  ];

  // object to json string, then to base64 (serde binary)
  const observationsBinaryString = toBinary(observations);

  const signed = signBinary(key, observationsBinaryString)

  const executeMsg = {
    submit_observations: {
      observations: observationsBinaryString,
      guardian_set_index: 0,
      signature: {
        index: 0,
        signature: Array.from(signed),
      },
    },
  };
  console.log(executeMsg);

  let inst = await cwc.execute(
    signer,
    accountingAddress,
    executeMsg,
    "auto"
  );
  let txHash = inst.transactionHash;
  console.log(`executed submit_observation! txHash: ${txHash}`);



  console.log("done, exiting success.")
}

try {
  main()
} catch (e) {
  console.error(e)
  throw e
}