test: convert warp npm test to go test

contracts/index.ts

@@ -1 +1 @@
-export { test } from './test/utils';
+export { Roles } from './test/utils';

contracts/test/utils.ts

@@ -1,7 +1,3 @@
-import { ethers } from "hardhat"
-import { Overrides } from "ethers"
-import assert from "assert"
-
 /*
  *
  * The `test` function is a wrapper around Mocha's `it` function. It provides a normalized framework for running the
@@ -37,96 +33,10 @@ import assert from "assert"
  */
 
 // Below are the types that help define all the different ways to call `test`
-type FnNameOrObject = string | string[] | MethodObject | MethodObject[]
-
-// Limit `from` property to be a `string` instead of `string | Promise<string>`
-type CallOverrides = Overrides & { from?: string }
-
-type MethodObject = { method: string, debug?: boolean, overrides?: CallOverrides, shouldFail?: boolean }
-
-// This type is after all default values have been applied
-type MethodWithDebugAndOverrides = MethodObject & { debug: boolean, overrides: CallOverrides, shouldFail: boolean }
-
-// `test` is used very similarly to `it` from Mocha
-export const test = (name, fnNameOrObject, overrides = {}) => it(name, buildTestFn(fnNameOrObject, overrides))
-// `test.only` is used very similarly to `it.only` from Mocha, it will isolate all tests marked with `test.only`
-test.only = (name, fnNameOrObject, overrides = {}) => it.only(name, buildTestFn(fnNameOrObject, overrides))
-// `test.debug` is used to apply `debug: true` to all DSTest contract method calls in the test
-test.debug = (name, fnNameOrObject, overrides = {}) => it.only(name, buildTestFn(fnNameOrObject, overrides, true))
-// `test.skip` is used very similarly to `it.skip` from Mocha, it will skip all tests marked with `test.skip`
-test.skip = (name, fnNameOrObject, overrides = {}) => it.skip(name, buildTestFn(fnNameOrObject, overrides))
-
-// `buildTestFn` is a higher-order function. It returns a function that can be used as the test function for `it`
-const buildTestFn = (fnNameOrObject: FnNameOrObject, overrides = {}, debug = false) => {
-  // normalize the input to an array of objects
-  const fnObjects: MethodWithDebugAndOverrides[] = (Array.isArray(fnNameOrObject) ? fnNameOrObject : [fnNameOrObject]).map(fnNameOrObject => {
-    fnNameOrObject = typeof fnNameOrObject === 'string' ? { method: fnNameOrObject } : fnNameOrObject
-    // assign all default values and overrides
-    fnNameOrObject.overrides = Object.assign({}, overrides, fnNameOrObject.overrides ?? {})
-    fnNameOrObject.debug = fnNameOrObject.debug ?? debug
-    fnNameOrObject.shouldFail = fnNameOrObject.shouldFail ?? false
-
-    return fnNameOrObject as MethodWithDebugAndOverrides
-  })
-
-  // only `step_` prefixed functions can be called on the `DSTest` contracts to clearly separate tests and helpers
-  assert(fnObjects.every(({ method }) => method.startsWith('step_')), "Solidity test functions must be prefixed with 'step_'")
-
-  // return the test function that will be used by `it`
-  // this function must be defined with the `function` keyword so that `this` is bound to the Mocha context
-  return async function () {
-    // `Array.prototype.reduce` is used here to ensure that the test functions are called in order.
-    // Each test function waits for its predecessor to complete before starting
-    return fnObjects.reduce((p: Promise<undefined>, fn) => p.then(async () => {
-      const contract = fn.overrides.from
-        ? this.testContract.connect(await ethers.getSigner(fn.overrides.from))
-        : this.testContract
-      const tx = await contract[fn.method](fn.overrides).catch(err => {
-        if (fn.shouldFail) {
-          if (fn.debug){
-             console.error(`smart contract call failed with error:\n${err}\n`)
-          }
-
-          return { failed: true }
-        }
-
-        console.error("smart contract call failed with error:", err)
-        throw err
-      })
-
-      // no more assertions necessary if the method-call should fail and did fail
-      if (tx.failed && fn.shouldFail) return
-
-      const txReceipt = await tx.wait().catch(err => {
-        if (fn.debug) console.error(`tx failed with error:\n${err}\n`)
-        return err.receipt
-      })
-
-      // `txReceipt.status` will be `0` if the transaction failed.
-      // `contract.failed` will return `true` if any of the `DSTest` assertions failed.
-      const failed = txReceipt.status === 0 ? true : await contract.failed.staticCall()
-      if (fn.debug || failed) {
-        console.log('')
-
-        if (!txReceipt.events) console.warn('WARNING: No parseable events found in tx-receipt\n')
-
-        // If `DSTest` assertions failed, the contract will emit logs describing the assertion failure(s).
-        txReceipt
-          .events
-          ?.filter(event => fn.debug || event.event?.startsWith('log'))
-          .map(event => event.args?.forEach(arg => console.log(arg)))
-
-        console.log('')
-      }
-
-      assert(!failed, `${fn.method} failed`)
-    }), Promise.resolve())
-  }
-}
 
 export const Roles = {
   None: 0,
   Enabled: 1,
   Admin: 2,
   Manager: 3,
-}
+}

contracts/contracts/ExampleWarp.sol → plugin/evm/ExampleWarp.sol

@@ -2,7 +2,7 @@
 pragma solidity ^0.8.24;
 pragma experimental ABIEncoderV2;
 
-import "./interfaces/IWarpMessenger.sol";
+import "precompile/contracts/warp/warpbindings/IWarpMessenger.sol";
 
 contract ExampleWarp {
   address constant WARP_ADDRESS = 0x0200000000000000000000000000000000000005;

precompile/contracts/warp/warpbindings/IWarpMessenger.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+struct WarpMessage {
+    bytes32 sourceChainID;
+    address originSenderAddress;
+    bytes payload;
+}
+
+struct WarpBlockHash {
+    bytes32 sourceChainID;
+    bytes32 blockHash;
+}
+
+interface IWarpMessenger {
+    event SendWarpMessage(
+        address indexed sender,
+        bytes32 indexed messageID,
+        bytes message
+    );
+
+    // sendWarpMessage emits a request for the subnet to send a warp message from [msg.sender]
+    // with the specified parameters.
+    // This emits a SendWarpMessage log from the precompile. When the corresponding block is accepted
+    // the Accept hook of the Warp precompile is invoked with all accepted logs emitted by the Warp
+    // precompile.
+    // Each validator then adds the UnsignedWarpMessage encoded in the log to the set of messages
+    // it is willing to sign for an off-chain relayer to aggregate Warp signatures.
+    function sendWarpMessage(
+        bytes calldata payload
+    ) external returns (bytes32 messageID);
+
+    // getVerifiedWarpMessage parses the pre-verified warp message in the
+    // predicate storage slots as a WarpMessage and returns it to the caller.
+    // If the message exists and passes verification, returns the verified message
+    // and true.
+    // Otherwise, returns false and the empty value for the message.
+    function getVerifiedWarpMessage(
+        uint32 index
+    ) external view returns (WarpMessage calldata message, bool valid);
+
+    // getVerifiedWarpBlockHash parses the pre-verified WarpBlockHash message in the
+    // predicate storage slots as a WarpBlockHash message and returns it to the caller.
+    // If the message exists and passes verification, returns the verified message
+    // and true.
+    // Otherwise, returns false and the empty value for the message.
+    function getVerifiedWarpBlockHash(
+        uint32 index
+    ) external view returns (WarpBlockHash calldata warpBlockHash, bool valid);
+
+    // getBlockchainID returns the snow.Context BlockchainID of this chain.
+    // This blockchainID is the hash of the transaction that created this blockchain on the P-Chain
+    // and is not related to the Ethereum ChainID.
+    function getBlockchainID() external view returns (bytes32 blockchainID);
+}

precompile/contracts/warp/warpbindings/compile.go

@@ -0,0 +1,12 @@
+// Copyright (C) 2019-2025, Ava Labs, Inc. All rights reserved.
+// See the file LICENSE for licensing terms.
+
+package warpbindings
+
+// Step 1: Compile Solidity contract to generate ABI and bin files
+//go:generate solc-v0.8.30 -o artifacts --overwrite --abi --bin --evm-version cancun IWarpMessenger.sol
+// Step 2: Generate Go bindings from the compiled artifacts
+//go:generate go run github.com/ava-labs/libevm/cmd/abigen --pkg warpbindings --type IWarpMessenger --abi artifacts/IWarpMessenger.abi --bin artifacts/IWarpMessenger.bin --out gen_iwarpmessenger_binding.go
+// Step 3: Replace import paths in generated binding to use subnet-evm instead of libevm
+// This is necessary because the libevm bindings package is not compatible with the subnet-evm simulated backend, which is used for testing.
+//go:generate sh -c "sed -i.bak -e 's|github.com/ava-labs/libevm/accounts/abi|github.com/ava-labs/subnet-evm/accounts/abi|g' -e 's|github.com/ava-labs/libevm/accounts/abi/bind|github.com/ava-labs/subnet-evm/accounts/abi/bind|g' gen_iwarpmessenger_binding.go && rm -f gen_iwarpmessenger_binding.go.bak"