mirror of
https://github.com/QuilibriumNetwork/ceremonyclient.git
synced 2026-02-21 18:37:26 +08:00
cee59c8131
wire issue for proxy worker init - h/t dogeanger moved injection from implicit to explicit for hypergraph operations bundle address resolution for multi-tx token interactions genesis shard init bug message subscriber for app -> global flow bug shard store save bug
417 lines
11 KiB
Go
417 lines
11 KiB
Go
package hypergraph_test
|
|
|
|
import (
|
|
"math/big"
|
|
"slices"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/require"
|
|
hgnode "source.quilibrium.com/quilibrium/monorepo/hypergraph"
|
|
"source.quilibrium.com/quilibrium/monorepo/node/execution/intrinsics/hypergraph"
|
|
"source.quilibrium.com/quilibrium/monorepo/node/keys"
|
|
"source.quilibrium.com/quilibrium/monorepo/types/crypto"
|
|
"source.quilibrium.com/quilibrium/monorepo/types/mocks"
|
|
qcrypto "source.quilibrium.com/quilibrium/monorepo/types/tries"
|
|
)
|
|
|
|
func TestVertexAddSerialization(t *testing.T) {
|
|
// Setup mocks
|
|
hg := &mocks.MockHypergraph{}
|
|
hg.On("GetProver").Return(&mocks.MockInclusionProver{})
|
|
verenc := &mocks.MockVerifiableEncryptor{}
|
|
proof := &mocks.MockVerEncProof{}
|
|
proof.On("GetEncryptionKey").Return(make([]byte, 57))
|
|
proof.On("Verify").Return(true)
|
|
proof.On("ToBytes").Return(make([]byte, 1100))
|
|
ve := &mocks.MockVerEnc{}
|
|
ve.On("ToBytes").Return(make([]byte, 1000))
|
|
ve.On("GetStatement").Return(make([]byte, 57))
|
|
proof.On("Compress").Return(ve)
|
|
verenc.On("ProofFromBytes", mock.Anything).Return(proof)
|
|
verenc.On("Encrypt", mock.Anything, mock.Anything).Return([]crypto.VerEncProof{proof})
|
|
|
|
// Create a test domain and data address
|
|
domain := [32]byte{1, 2, 3, 4, 5}
|
|
dataAddress := [32]byte{6, 7, 8, 9, 10}
|
|
|
|
// Create a signer
|
|
signer, err := keys.NewEd448Key()
|
|
require.NoError(t, err)
|
|
|
|
// Create a VertexAdd instance
|
|
vertexAdd := hypergraph.NewVertexAdd(
|
|
domain,
|
|
dataAddress,
|
|
[]byte{0, 1, 2, 3},
|
|
signer.Public().([]byte),
|
|
hg.GetProver(),
|
|
signer,
|
|
&hypergraph.HypergraphIntrinsicConfiguration{
|
|
ReadPublicKey: signer.Public().([]byte),
|
|
WritePublicKey: signer.Public().([]byte),
|
|
},
|
|
verenc,
|
|
keys.NewInMemoryKeyManager(nil, nil),
|
|
)
|
|
|
|
err = vertexAdd.Prove(0)
|
|
require.NoError(t, err)
|
|
|
|
// Serialize the VertexAdd
|
|
bytes, err := vertexAdd.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytes)
|
|
|
|
// Deserialize and verify
|
|
newVertexAdd := hypergraph.NewVertexAdd(domain, dataAddress, nil, nil, nil, nil, nil, verenc, nil)
|
|
err = newVertexAdd.FromBytes(
|
|
bytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
// Verify fields match
|
|
assert.Equal(t, vertexAdd.Domain, newVertexAdd.Domain)
|
|
assert.Equal(t, vertexAdd.DataAddress, newVertexAdd.DataAddress)
|
|
assert.NotNil(t, newVertexAdd.Data)
|
|
|
|
// Verify serialization with nil Data
|
|
vertexAddNilData := hypergraph.NewVertexAdd(
|
|
domain,
|
|
dataAddress,
|
|
nil,
|
|
signer.Public().([]byte),
|
|
hg.GetProver(),
|
|
signer,
|
|
&hypergraph.HypergraphIntrinsicConfiguration{
|
|
ReadPublicKey: signer.Public().([]byte),
|
|
WritePublicKey: signer.Public().([]byte),
|
|
},
|
|
verenc,
|
|
keys.NewInMemoryKeyManager(nil, nil),
|
|
)
|
|
|
|
bytesNilData, err := vertexAddNilData.ToBytes()
|
|
require.Error(t, err)
|
|
require.Nil(t, bytesNilData)
|
|
}
|
|
|
|
func TestVertexRemoveSerialization(t *testing.T) {
|
|
// Create a test domain, data address, and other required fields
|
|
domain := [32]byte{1, 2, 3, 4, 5}
|
|
dataAddress := [32]byte{6, 7, 8, 9, 10}
|
|
|
|
// Create a signer
|
|
signer, err := keys.NewEd448Key()
|
|
require.NoError(t, err)
|
|
|
|
// Create a VertexRemove instance
|
|
vertexRemove := hypergraph.NewVertexRemove(
|
|
domain,
|
|
dataAddress,
|
|
signer,
|
|
)
|
|
|
|
// Serialize the VertexRemove
|
|
bytes, err := vertexRemove.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytes)
|
|
|
|
// Deserialize and verify
|
|
newVertexRemove := &hypergraph.VertexRemove{}
|
|
err = newVertexRemove.FromBytes(
|
|
bytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
// Verify fields match
|
|
assert.Equal(t, vertexRemove.Domain, newVertexRemove.Domain)
|
|
assert.Equal(t, vertexRemove.DataAddress, newVertexRemove.DataAddress)
|
|
// originalSize and commitment are private fields, but we can verify
|
|
// they're properly initialized by using GetCost and Verify
|
|
|
|
// No need to test with nil since the new constructor doesn't take those parameters
|
|
}
|
|
|
|
func TestHyperedgeAddSerialization(t *testing.T) {
|
|
// Setup mocks
|
|
|
|
mockHg := &mocks.MockHypergraph{}
|
|
mockHg.On("GetProver").Return(&mocks.MockInclusionProver{})
|
|
mockHyperedge := &mocks.MockHyperedge{}
|
|
|
|
vert := hgnode.NewVertex([32]byte(make([]byte, 32)), [32]byte(make([]byte, 32)), make([]byte, 74), big.NewInt(74))
|
|
tree := &qcrypto.VectorCommitmentTree{}
|
|
tree.Insert(make([]byte, 64), vert.ToBytes(), nil, vert.GetSize())
|
|
tbytes, err := qcrypto.SerializeNonLazyTree(tree)
|
|
require.NoError(t, err)
|
|
|
|
// Setup hyperedge mock
|
|
hyperedgeID := [64]byte{1, 2, 3, 4, 5, 6, 7, 8}
|
|
mockHyperedge.On("GetID").Return(hyperedgeID)
|
|
mockHyperedge.On("GetSize").Return(big.NewInt(42))
|
|
mockHyperedge.On("ToBytes").Return(slices.Concat([]byte{0x01}, hyperedgeID[:], tbytes), nil)
|
|
mockHg.On("NewHyperedge").Return(mockHyperedge, nil)
|
|
mockHyperedge.On("FromBytes", mock.Anything).Return(nil)
|
|
|
|
// Create a test domain
|
|
domain := [32]byte{1, 2, 3, 4, 5}
|
|
|
|
// Create mock prover and signer
|
|
mockProver := &mocks.MockInclusionProver{}
|
|
signer, err := keys.NewEd448Key()
|
|
require.NoError(t, err)
|
|
|
|
// Create a HyperedgeAdd instance
|
|
hyperedgeAdd := hypergraph.NewHyperedgeAdd(
|
|
domain,
|
|
mockHyperedge,
|
|
mockProver,
|
|
signer,
|
|
)
|
|
|
|
// Serialize the HyperedgeAdd
|
|
bytes, err := hyperedgeAdd.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytes)
|
|
// Deserialize and verify
|
|
newHyperedgeAdd := &hypergraph.HyperedgeAdd{}
|
|
err = newHyperedgeAdd.FromBytes(
|
|
bytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
// Verify fields match
|
|
assert.Equal(t, hyperedgeAdd.Domain, newHyperedgeAdd.Domain)
|
|
assert.NotNil(t, newHyperedgeAdd.Value)
|
|
|
|
// Test with nil Value
|
|
hyperedgeAddNil := hypergraph.NewHyperedgeAdd(
|
|
domain,
|
|
nil,
|
|
mockProver,
|
|
signer,
|
|
)
|
|
|
|
bytesNil, err := hyperedgeAddNil.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytesNil)
|
|
|
|
newHyperedgeAddNil := &hypergraph.HyperedgeAdd{}
|
|
err = newHyperedgeAddNil.FromBytes(
|
|
bytesNil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, hyperedgeAddNil.Domain, newHyperedgeAddNil.Domain)
|
|
assert.Nil(t, newHyperedgeAddNil.Value)
|
|
}
|
|
|
|
func TestHyperedgeRemoveSerialization(t *testing.T) {
|
|
// Setup mocks
|
|
mockHg := &mocks.MockHypergraph{}
|
|
mockHyperedge := &mocks.MockHyperedge{}
|
|
|
|
vert := hgnode.NewVertex([32]byte(make([]byte, 32)), [32]byte(make([]byte, 32)), make([]byte, 74), big.NewInt(74))
|
|
tree := &qcrypto.VectorCommitmentTree{}
|
|
tree.Insert(make([]byte, 64), vert.ToBytes(), nil, vert.GetSize())
|
|
tbytes, err := qcrypto.SerializeNonLazyTree(tree)
|
|
require.NoError(t, err)
|
|
|
|
// Setup hyperedge mock
|
|
hyperedgeID := [64]byte{1, 2, 3, 4, 5, 6, 7, 8}
|
|
mockHyperedge.On("GetID").Return(hyperedgeID)
|
|
mockHyperedge.On("ToBytes").Return(slices.Concat([]byte{0x01}, hyperedgeID[:], tbytes), nil)
|
|
mockHg.On("NewHyperedge").Return(mockHyperedge, nil)
|
|
mockHyperedge.On("FromBytes", mock.Anything).Return(nil)
|
|
|
|
// Create a test domain
|
|
domain := [32]byte{1, 2, 3, 4, 5}
|
|
|
|
// Create signer
|
|
signer, err := keys.NewEd448Key()
|
|
require.NoError(t, err)
|
|
|
|
// Create a HyperedgeRemove instance
|
|
hyperedgeRemove := hypergraph.NewHyperedgeRemove(
|
|
domain,
|
|
mockHyperedge,
|
|
signer,
|
|
)
|
|
|
|
// Serialize the HyperedgeRemove
|
|
bytes, err := hyperedgeRemove.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytes)
|
|
|
|
// Deserialize and verify
|
|
newHyperedgeRemove := &hypergraph.HyperedgeRemove{}
|
|
err = newHyperedgeRemove.FromBytes(
|
|
bytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
// Verify fields match
|
|
assert.Equal(t, hyperedgeRemove.Domain, newHyperedgeRemove.Domain)
|
|
assert.NotNil(t, newHyperedgeRemove.Value)
|
|
|
|
// Test with nil Value
|
|
hyperedgeRemoveNil := hypergraph.NewHyperedgeRemove(
|
|
domain,
|
|
nil,
|
|
signer,
|
|
)
|
|
|
|
bytesNil, err := hyperedgeRemoveNil.ToBytes()
|
|
require.NoError(t, err)
|
|
require.NotNil(t, bytesNil)
|
|
|
|
newHyperedgeRemoveNil := &hypergraph.HyperedgeRemove{}
|
|
err = newHyperedgeRemoveNil.FromBytes(
|
|
bytesNil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
assert.Equal(t, hyperedgeRemoveNil.Domain, newHyperedgeRemoveNil.Domain)
|
|
assert.Nil(t, newHyperedgeRemoveNil.Value)
|
|
}
|
|
|
|
func TestInvalidSerialization(t *testing.T) {
|
|
// Setup mocks
|
|
mockInclusionProver := &mocks.MockInclusionProver{}
|
|
mockVerenc := &mocks.MockVerifiableEncryptor{}
|
|
proof := &mocks.MockVerEncProof{}
|
|
proof.On("GetEncryptionKey").Return(make([]byte, 57))
|
|
proof.On("Verify").Return(true)
|
|
proof.On("ToBytes").Return(make([]byte, 1100))
|
|
ve := &mocks.MockVerEnc{}
|
|
ve.On("ToBytes").Return(make([]byte, 1000))
|
|
ve.On("GetStatement").Return(make([]byte, 57))
|
|
mockVerenc.On("Encrypt", mock.Anything, mock.Anything).Return([]crypto.VerEncProof{proof})
|
|
proof.On("Compress").Return(ve)
|
|
mockVerenc.On("ProofFromBytes", mock.Anything).Return(proof)
|
|
|
|
// Create a test domain and data address
|
|
domain := [32]byte{1, 2, 3, 4, 5}
|
|
dataAddress := [32]byte{6, 7, 8, 9, 10}
|
|
|
|
// Create a signer
|
|
signer, err := keys.NewEd448Key()
|
|
require.NoError(t, err)
|
|
|
|
// Create a VertexAdd instance
|
|
vertexAdd := hypergraph.NewVertexAdd(
|
|
domain,
|
|
dataAddress,
|
|
make([]byte, 32),
|
|
signer.Public().([]byte),
|
|
mockInclusionProver,
|
|
signer,
|
|
&hypergraph.HypergraphIntrinsicConfiguration{
|
|
ReadPublicKey: signer.Public().([]byte),
|
|
WritePublicKey: signer.Public().([]byte),
|
|
},
|
|
mockVerenc,
|
|
keys.NewInMemoryKeyManager(nil, nil),
|
|
)
|
|
|
|
err = vertexAdd.Prove(0)
|
|
require.NoError(t, err)
|
|
|
|
// Serialize the VertexAdd
|
|
bytes, err := vertexAdd.ToBytes()
|
|
require.NoError(t, err)
|
|
|
|
// Test with truncated data
|
|
truncatedBytes := bytes[:len(bytes)/2]
|
|
newVertexAdd := &hypergraph.VertexAdd{}
|
|
err = newVertexAdd.FromBytes(
|
|
truncatedBytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "from bytes")
|
|
|
|
// Test with empty data
|
|
emptyVertexAdd := &hypergraph.VertexAdd{}
|
|
err = emptyVertexAdd.FromBytes(
|
|
[]byte{},
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
assert.Error(t, err)
|
|
|
|
// Test with corrupted data - wrong type
|
|
corruptedBytes := make([]byte, len(bytes))
|
|
copy(corruptedBytes, bytes)
|
|
corruptedBytes[0] = 0xFF // Set invalid type
|
|
corruptedVertexAdd := &hypergraph.VertexAdd{}
|
|
err = corruptedVertexAdd.FromBytes(
|
|
corruptedBytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid type")
|
|
|
|
mockhe := &mocks.MockHyperedge{}
|
|
mockhe.On("ToBytes").Return([]byte("invalid-data"))
|
|
// Test HyperedgeAdd deserialization with invalid data
|
|
hyperedgeAdd := hypergraph.NewHyperedgeAdd(
|
|
domain,
|
|
mockhe,
|
|
mockInclusionProver,
|
|
signer,
|
|
)
|
|
|
|
hyperedgeBytes, err := hyperedgeAdd.ToBytes()
|
|
require.NoError(t, err)
|
|
|
|
corruptedHyperedgeBytes := make([]byte, len(hyperedgeBytes))
|
|
copy(corruptedHyperedgeBytes, hyperedgeBytes)
|
|
corruptedHyperedgeBytes[0] = 0xFF // Set invalid type
|
|
corruptedHyperedgeAdd := &hypergraph.HyperedgeAdd{}
|
|
err = corruptedHyperedgeAdd.FromBytes(
|
|
corruptedHyperedgeBytes,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
nil,
|
|
)
|
|
assert.Error(t, err)
|
|
assert.Contains(t, err.Error(), "invalid type")
|
|
}
|