maker/dexpoolid_test.go

package maker

import (
	"encoding/hex"
	"testing"
)

// dexpoolid_test.go proves DEFECT-1 is fixed: the maker derives a symbol's
// poolId by the SAME convention every native venue rail uses, so a seeded book
// lands at the SAME 32-byte id the FIX, WS, and precompile rails address.
//
// The venue convention has THREE byte-identical homes:
//   - github.com/luxfi/dex/pkg/venue.SymbolToPoolID   (venue.go:140-145, FIX/WS)
//   - github.com/luxfi/dex/pkg/dchain.poolIDForSymbol (localnet_e2e_test.go:65-71)
//   - github.com/luxfi/dex/cmd/fourpath-live.poolIDForSymbol (main.go:72-77)
//
// All three are: copy ASCII(symbol) left-aligned into [32]byte, then set
// byte[31]=0xD0. We do NOT import dex/pkg/venue (that drags the whole dex module
// — and a geth minor bump — in for a 4-line pure function; the DEX's own pattern
// is to re-declare the frozen frame locally and assert byte-equality, exactly as
// dex.go's header documents). So we (a) re-state the venue algorithm verbatim as
// a reference and assert SymbolPoolID == it, and (b) pin the captured ground-truth
// hex the venue functions emit, so a drift in EITHER fails the build.

// venueSymbolToPoolID is copied VERBATIM from dex/pkg/venue/venue.go:140-145
// (== dchain.poolIDForSymbol == fourpath-live.poolIDForSymbol). If the venue ever
// changes the convention, this reference and the pinned vectors below must change
// together — and this test is where that divergence surfaces.
func venueSymbolToPoolID(symbol string) [32]byte {
	var p [32]byte
	copy(p[:], symbol)
	p[31] = 0xD0
	return p
}

func TestSymbolPoolIDMatchesVenueConvention(t *testing.T) {
	for _, sym := range []string{"LUX/LUSD", "LUX/LETH", "FOO/BAR", ""} {
		got := SymbolPoolID(sym)
		want := venueSymbolToPoolID(sym)
		if got != want {
			t.Errorf("SymbolPoolID(%q) = %x, venue convention = %x", sym, got, want)
		}
		// The 0xD0 high-byte tag must always be present (collision guard vs the
		// all-zero native asset id).
		if got[31] != 0xD0 {
			t.Errorf("SymbolPoolID(%q) byte[31] = 0x%02x, want 0xD0", sym, got[31])
		}
	}
}

// TestSymbolPoolIDGroundTruthVectors pins the EXACT hex the canonical venue
// functions emit for the two canonical devnet symbols (captured from the venue
// algorithm). A maker that frames a different poolId would route to a different
// book than every other rail — these vectors make that a build failure.
func TestSymbolPoolIDGroundTruthVectors(t *testing.T) {
	vectors := map[string]string{
		// 4c55582f4c555344 = ASCII "LUX/LUSD", left-aligned, byte[31]=0xd0.
		"LUX/LUSD": "4c55582f4c5553440000000000000000000000000000000000000000000000d0",
		// 4c55582f4c455448 = ASCII "LUX/LETH".
		"LUX/LETH": "4c55582f4c4554480000000000000000000000000000000000000000000000d0",
	}
	for sym, wantHex := range vectors {
		got := SymbolPoolID(sym)
		if h := hex.EncodeToString(got[:]); h != wantHex {
			t.Errorf("SymbolPoolID(%q) = %s, want %s", sym, h, wantHex)
		}
	}
}

// TestNotKeccakPoolID guards against a regression to the OLD keccak256(symbol)
// derivation (DEFECT 1): the keccak of "LUX/LUSD" has no 0xD0 tail and differs
// from the venue id, so a keccak-derived id would never carry byte[31]=0xD0 with
// the ASCII prefix intact.
func TestNotKeccakPoolID(t *testing.T) {
	id := SymbolPoolID("LUX/LUSD")
	// ASCII prefix must be the literal symbol bytes (keccak would scramble them).
	if string(id[:8]) != "LUX/LUSD" {
		t.Errorf("poolId prefix = %q, want literal symbol bytes (keccak regression?)", id[:8])
	}
}