megred post audit contract changes

Author: Aman035

api/uregistry/v1/query.pulsar.go

@@ -30,44 +30,56 @@ address constant USigVerifier_PRECOMPILE_ADDRESS    = 0x000000000000000000000000
 address constant USigVerifier_PRECOMPILE_ADDRESS_V2 = 0xEC00000000000000000000000000000000000001;
 
 interface IUSigVerifier {
-    /// @notice Verifies an Ed25519 signature.
-    /// @param pubKey    The 32-byte Ed25519 public key (Solana address bytes).
-    /// @param msg       The message digest that was signed (bytes32).
-    /// @param signature The 64-byte Ed25519 signature.
-    /// @return isValid  True iff the signature is valid for (pubKey, msg).
-    function verifyEd25519(
-        bytes calldata pubKey,
-        bytes32 msg,
-        bytes calldata signature
-    ) external view returns (bool);
+    /// Verifies signature over `"0x" + hex(msgDigest)` (66 ASCII bytes).
+    /// Used by UEA_SVM. Solana wallets render the hex string in their sign-message UI.
+    function verifyEd25519(bytes calldata pubKey, bytes32 msgDigest, bytes calldata signature)
+        external view returns (bool);
+
+    /// Verifies signature over the raw message bytes (standard Ed25519 semantics).
+    /// Use this if your signer uses the conventional `ed25519.Sign(privKey, rawBytes)` API.
+    function verifyEd25519RawMessage(bytes calldata pubKey, bytes calldata message, bytes calldata signature)
+        external view returns (bool);
 }
 ```
 
-| Property | Value |
-|---|---|
-| Method | `verifyEd25519(bytes,bytes32,bytes)` |
-| State mutability | `view` (no on-chain state is touched) |
-| Gas cost | `4000` per call (`VerifyEd25519Gas` in `usigverifier.go`) |
+| Method | Signed bytes | Gas | Use when |
+|---|---|---|---|
+| `verifyEd25519(bytes,bytes32,bytes)` | `"0x" + hex(msgDigest)` (66 ASCII bytes) | 4000 | UEA_SVM / Solana-wallet flows where the user signs a hex string in Phantom/Solflare |
+| `verifyEd25519RawMessage(bytes,bytes,bytes)` | Raw `message` bytes | 4000 | New integrations / relayers using standard `ed25519.Sign(privKey, rawBytes)` |
+
+Both methods are `view` and touch no chain state.
 
 ## Verification Semantics
 
-The precompile is intentionally narrow. It accepts:
+Two methods, two distinct signing conventions. **A signature produced for one method will not verify under the other** — the test vectors in `query_test.go` lock this in.
 
-- `pubKey` — 32 raw Ed25519 public key bytes (a Solana address is exactly this)
-- `msg` — a single `bytes32` digest
-- `signature` — 64 raw Ed25519 signature bytes
+### `verifyEd25519` — hex-ASCII convention (legacy / wallet-friendly)
 
-Internally (`query.go:VerifyEd25519`), the `bytes32` digest is **rendered as a 0x-prefixed hex string** before being passed to `ed25519.Verify`:
+Internally (`query.go:VerifyEd25519`), the `bytes32` `msgDigest` is rendered as a 0x-prefixed hex string before being passed to `ed25519.Verify`:
 
 ```go
 msgStr := "0x" + hex.EncodeToString(msg)  // 66 ASCII bytes
 msgBytes := []byte(msgStr)
 ok = ed25519.Verify(pubKeyBytes, msgBytes, signature)
 ```
 
-In other words, the signed message that the off-chain signer must sign is the **66-byte ASCII string** `0x...` of the digest, not the raw 32 bytes. This matches the convention used by Solana wallets when signing arbitrary messages — they prefix-encode the payload — so a normal Solana wallet signature over a Push Chain message hash will verify here without any extra work on the wallet side.
+The off-chain signer must sign the **66-byte ASCII string** `"0x"+hex(digest)`, not the raw 32 bytes. This is what UEA_SVM uses so that a Solana wallet (Phantom, Solflare) shows the user a copy-pasteable hex string in its sign-message prompt rather than opaque bytes.
+
+### `verifyEd25519RawMessage` — raw-bytes convention (standard)
+
+Standard Ed25519 verification — signature is checked against the raw `message` bytes:
+
+```go
+ok = ed25519.Verify(pubKeyBytes, message, signature)
+```
+
+Use this when your signer uses `ed25519.Sign(privKey, rawBytes)` (default in every Solana SDK / nacl library). `message` may be any length, not just 32 bytes.
+
+### Common rules
 
-If `pubKey` is not 32 bytes or `signature` is not 64 bytes, the precompile reverts with `invalid params`. Unknown method IDs revert with the standard `unknown method` error.
+- `pubKey` must be exactly 32 bytes; `signature` must be exactly 64 bytes — otherwise the precompile reverts with `invalid params`.
+- Unknown method IDs revert with the standard `unknown method` error.
+- Both methods cost `4000` gas.
 
 ## Generating the ABI
 

api/utss/v1/types.pulsar.go

@@ -15,10 +15,26 @@ IUSigVerifier constant USigVerifier_CONTRACT_V2 = IUSigVerifier(USigVerifier_PRE
 
 /// @dev The IUSigVerifier contract's interface.
 interface IUSigVerifier {
-    /// @notice Verifies a signature using Ed25519
-    /// @param pubKey The base58-encoded public key (Solana address)
-    /// @param msg The message that was signed
-    /// @param signature The signature to verify
-    /// @return isValid True if the signature is valid
-    function verifyEd25519(bytes calldata pubKey, bytes32 msg, bytes calldata signature) external view returns (bool);
+    /// @notice Verifies an Ed25519 signature over the ASCII hex form of msgDigest.
+    /// @dev The signature MUST be produced over the 66-byte UTF-8 sequence
+    ///      `"0x" + hex(msgDigest)`, NOT over the raw 32 bytes of msgDigest.
+    ///      This convention exists so Solana wallets (Phantom, Solflare, etc.)
+    ///      display a human-readable hex string in their sign-message prompt.
+    ///      For raw-bytes semantics, use {verifyEd25519RawMessage}.
+    /// @param pubKey 32-byte Ed25519 public key (a Solana address is exactly this).
+    /// @param msgDigest The 32-byte digest. Off-chain signer must sign `"0x" + hex(msgDigest)` (66 bytes).
+    /// @param signature 64-byte Ed25519 signature.
+    /// @return isValid True iff signature is valid for (pubKey, "0x"+hex(msgDigest)).
+    function verifyEd25519(bytes calldata pubKey, bytes32 msgDigest, bytes calldata signature) external view returns (bool);
+
+    /// @notice Verifies an Ed25519 signature over raw message bytes.
+    /// @dev Standard Ed25519 verification: signature is checked against the raw
+    ///      bytes of `message`. Use this when your off-chain signer uses the
+    ///      conventional `ed25519.Sign(privKey, rawBytes)` API (the default in
+    ///      every Solana SDK / nacl library).
+    /// @param pubKey 32-byte Ed25519 public key.
+    /// @param message Raw message bytes that were signed (any length).
+    /// @param signature 64-byte Ed25519 signature.
+    /// @return isValid True iff signature is valid for (pubKey, message).
+    function verifyEd25519RawMessage(bytes calldata pubKey, bytes calldata message, bytes calldata signature) external view returns (bool);
 }

precompiles/usigverifier/README.md

@@ -16,7 +16,7 @@
         },
         {
           "internalType": "bytes32",
-          "name": "msg",
+          "name": "msgDigest",
           "type": "bytes32"
         },
         {
@@ -35,6 +35,35 @@
       ],
       "stateMutability": "view",
       "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes",
+          "name": "pubKey",
+          "type": "bytes"
+        },
+        {
+          "internalType": "bytes",
+          "name": "message",
+          "type": "bytes"
+        },
+        {
+          "internalType": "bytes",
+          "name": "signature",
+          "type": "bytes"
+        }
+      ],
+      "name": "verifyEd25519RawMessage",
+      "outputs": [
+        {
+          "internalType": "bool",
+          "name": "",
+          "type": "bool"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
     }
   ]
 }

precompiles/usigverifier/USigVerifier.sol

@@ -8,8 +8,13 @@ import (
 	"github.com/ethereum/go-ethereum/accounts/abi"
 )
 
-const VerifyEd25519Method = "verifyEd25519"
+const (
+	VerifyEd25519Method           = "verifyEd25519"
+	VerifyEd25519RawMessageMethod = "verifyEd25519RawMessage"
+)
 
+// VerifyEd25519 verifies a signature over the ASCII bytes of "0x"+hex(msgDigest).
+// This is the legacy / Solana-wallet-friendly form used by UEA_SVM.
 func (p Precompile) VerifyEd25519(
 	method *abi.Method,
 	args []interface{},
@@ -50,6 +55,43 @@ func (p Precompile) VerifyEd25519(
 	return method.Outputs.Pack(ok)
 }
 
+// VerifyEd25519RawMessage verifies a signature over raw message bytes —
+// standard Ed25519 semantics. Use this when the signer used the conventional
+// ed25519.Sign(privKey, rawBytes) API.
+func (p Precompile) VerifyEd25519RawMessage(
+	method *abi.Method,
+	args []interface{},
+) ([]byte, error) {
+
+	pubKey, ok := args[0].([]byte)
+	if !ok {
+		return nil, fmt.Errorf("invalid pubKey type")
+	}
+
+	message, ok := args[1].([]byte)
+	if !ok {
+		return nil, fmt.Errorf("invalid message type")
+	}
+
+	signature, ok := args[2].([]byte)
+	if !ok {
+		return nil, fmt.Errorf("invalid signature type")
+	}
+
+	pubKeyBytes, err := getSolanaPubKeyFromAddress(pubKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse pubKey: %w", err)
+	}
+
+	if len(pubKeyBytes) != ed25519.PublicKeySize || len(signature) != ed25519.SignatureSize {
+		return nil, fmt.Errorf("invalid params")
+	}
+
+	ok = ed25519.Verify(pubKeyBytes, message, signature)
+
+	return method.Outputs.Pack(ok)
+}
+
 func getSolanaPubKeyFromAddress(pubKey []byte) (ed25519.PublicKey, error) {
 	return ed25519.PublicKey(pubKey), nil
 }

precompiles/usigverifier/abi.json

@@ -0,0 +1,105 @@
+package usigverifier
+
+import (
+	"crypto/ed25519"
+	"encoding/hex"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// Fixed test vectors locking in the two distinct signing conventions exposed
+// by the precompile (F-2026-17043 remediation).
+//
+//   - verifyEd25519:    signature must be over `"0x" + hex(msgDigest)` (66 ASCII bytes)
+//   - verifyEd25519RawMessage: signature must be over the raw message bytes
+//
+// A signature produced for one convention MUST NOT verify under the other.
+
+// Deterministic seed so the test vectors below are reproducible and inspectable.
+// Anyone can re-derive these by running ed25519.NewKeyFromSeed on this 32-byte seed.
+var testSeed = mustHex("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f")
+
+// A 32-byte digest used as the input to both methods. Same input, different
+// signing semantics — that's the whole point of the two methods.
+var testDigest32 = mustHex("deadbeef00112233445566778899aabbccddeeff0123456789abcdef00ff00ff")
+
+func TestVerifyEd25519_AcceptsHexAsciiSignature(t *testing.T) {
+	priv := ed25519.NewKeyFromSeed(testSeed)
+	pub := priv.Public().(ed25519.PublicKey)
+
+	// What verifyEd25519 expects the signer to have signed.
+	hexAsciiBytes := []byte("0x" + hex.EncodeToString(testDigest32))
+	require.Len(t, hexAsciiBytes, 66, "ASCII hex form must be 66 bytes (0x + 64 hex chars)")
+
+	sig := ed25519.Sign(priv, hexAsciiBytes)
+	require.True(t, ed25519.Verify(pub, hexAsciiBytes, sig),
+		"sanity: signature must verify against the bytes that were signed")
+
+	// What verifyEd25519 actually verifies internally:
+	verified := ed25519.Verify(pub, []byte("0x"+hex.EncodeToString(testDigest32)), sig)
+	require.True(t, verified, "verifyEd25519 must accept signature over hex-ASCII form of digest")
+}
+
+func TestVerifyEd25519_RejectsRawDigestSignature(t *testing.T) {
+	priv := ed25519.NewKeyFromSeed(testSeed)
+	pub := priv.Public().(ed25519.PublicKey)
+
+	// Signer mistakenly signs the raw 32-byte digest (the "natural" thing).
+	rawDigestSig := ed25519.Sign(priv, testDigest32)
+
+	// What verifyEd25519 actually verifies internally:
+	verified := ed25519.Verify(pub, []byte("0x"+hex.EncodeToString(testDigest32)), rawDigestSig)
+	require.False(t, verified, "verifyEd25519 must reject signature over raw digest bytes")
+}
+
+func TestVerifyEd25519RawMessage_AcceptsRawSignature(t *testing.T) {
+	priv := ed25519.NewKeyFromSeed(testSeed)
+	pub := priv.Public().(ed25519.PublicKey)
+
+	// What verifyEd25519RawMessage expects: signature over the raw message bytes.
+	rawSig := ed25519.Sign(priv, testDigest32)
+
+	// What verifyEd25519RawMessage actually verifies internally:
+	verified := ed25519.Verify(pub, testDigest32, rawSig)
+	require.True(t, verified, "verifyEd25519RawMessage must accept signature over raw bytes")
+}
+
+func TestVerifyEd25519RawMessage_RejectsHexAsciiSignature(t *testing.T) {
+	priv := ed25519.NewKeyFromSeed(testSeed)
+	pub := priv.Public().(ed25519.PublicKey)
+
+	// Signer (using legacy convention) signs the hex-ASCII form.
+	hexAsciiSig := ed25519.Sign(priv, []byte("0x"+hex.EncodeToString(testDigest32)))
+
+	// What verifyEd25519RawMessage actually verifies internally:
+	verified := ed25519.Verify(pub, testDigest32, hexAsciiSig)
+	require.False(t, verified, "verifyEd25519RawMessage must reject signature over hex-ASCII form")
+}
+
+// TestVerifyEd25519RawMessage_ArbitraryMessageLength sanity-checks that the raw
+// method works for messages other than 32-byte digests (its whole point —
+// no implicit assumption that the message is a digest).
+func TestVerifyEd25519RawMessage_ArbitraryMessageLength(t *testing.T) {
+	priv := ed25519.NewKeyFromSeed(testSeed)
+	pub := priv.Public().(ed25519.PublicKey)
+
+	for _, msg := range [][]byte{
+		[]byte("hello"),
+		make([]byte, 0),                       // empty
+		make([]byte, 1024),                    // 1 KiB
+		[]byte{0x00, 0x01, 0x02, 0x03, 0xff}, // arbitrary short
+	} {
+		sig := ed25519.Sign(priv, msg)
+		require.True(t, ed25519.Verify(pub, msg, sig),
+			"verifyEd25519RawMessage must work for messages of any length (len=%d)", len(msg))
+	}
+}
+
+func mustHex(s string) []byte {
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}

precompiles/usigverifier/query.go

@@ -16,6 +16,9 @@ const (
 	USigVerifierPrecompileAddress = "0xEC00000000000000000000000000000000000001"
 	// VerifyEd25519Gas is the gas cost for verifying an Ed25519 signature.
 	VerifyEd25519Gas uint64 = 4000
+	// VerifyEd25519RawMessageGas matches VerifyEd25519Gas — same Ed25519
+	// verification cost, only the message-prep step differs (no hex encoding).
+	VerifyEd25519RawMessageGas uint64 = 4000
 )
 
 var _ vm.PrecompiledContract = &Precompile{}
@@ -70,6 +73,8 @@ func (p Precompile) RequiredGas(input []byte) uint64 {
 	switch method.Name {
 	case VerifyEd25519Method:
 		return VerifyEd25519Gas
+	case VerifyEd25519RawMessageMethod:
+		return VerifyEd25519RawMessageGas
 	default:
 		return p.Precompile.RequiredGas(input, p.IsTransaction(method))
 	}
@@ -97,6 +102,8 @@ func (p Precompile) Run(evm *vm.EVM, contract *vm.Contract, readOnly bool) (bz [
 	switch method.Name {
 	case VerifyEd25519Method:
 		bz, err = p.VerifyEd25519(method, args)
+	case VerifyEd25519RawMessageMethod:
+		bz, err = p.VerifyEd25519RawMessage(method, args)
 	default:
 		return nil, fmt.Errorf(cmn.ErrUnknownMethod, method.Name)
 	}

precompiles/usigverifier/query_test.go

@@ -1,6 +1,7 @@
 syntax = "proto3";
 package uregistry.v1;
 
+import "cosmos/base/query/v1beta1/pagination.proto";
 import "google/api/annotations.proto";
 import "uregistry/v1/genesis.proto";
 import "uregistry/v1/types.proto";
@@ -61,11 +62,14 @@ message QueryChainConfigResponse {
 }
 
 // QueryAllChainConfigsRequest is the request type for the Query/AllChainConfigs RPC method.
-message QueryAllChainConfigsRequest {}
+message QueryAllChainConfigsRequest {
+  cosmos.base.query.v1beta1.PageRequest pagination = 1;
+}
 
 // QueryAllChainConfigsResponse is the response type for the Query/AllChainConfigs RPC method.
 message QueryAllChainConfigsResponse {
   repeated ChainConfig configs = 1;
+  cosmos.base.query.v1beta1.PageResponse pagination = 2;
 }
 
 // TokenConfig
@@ -81,19 +85,24 @@ message QueryTokenConfigResponse {
 }
 
 // QueryAllTokenConfigsRequest is the request type for the Query/AllTokenConfigs RPC method.
-message QueryAllTokenConfigsRequest {}
+message QueryAllTokenConfigsRequest {
+  cosmos.base.query.v1beta1.PageRequest pagination = 1;
+}
 
 // QueryAllTokenConfigsResponse is the response type for the Query/AllTokenConfigs RPC method.
 message QueryAllTokenConfigsResponse {
   repeated TokenConfig configs = 1;
+  cosmos.base.query.v1beta1.PageResponse pagination = 2;
 }
 
 // QueryTokenConfigsByChainRequest is the request type for the Query/TokenConfigsByChain RPC method.
 message QueryTokenConfigsByChainRequest {
   string chain = 1;
+  cosmos.base.query.v1beta1.PageRequest pagination = 2;
 }
 
 // QueryTokenConfigsByChainResponse is the response type for the Query/TokenConfigsByChain RPC method.
 message QueryTokenConfigsByChainResponse {
   repeated TokenConfig configs = 1;
+  cosmos.base.query.v1beta1.PageResponse pagination = 2;
 }