Skip to content

feat(rpc): update consensus power #63

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Draft
huancheng-trili wants to merge 1 commit into
base: 51-remove-adaptive-issuance-vote
Choose a base branch
from
Draft

feat(rpc): update consensus power #63

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
283 changes: 270 additions & 13 deletions rpc/attestations_aggregate_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,7 +4,10 @@
package rpc

import (
"bytes"
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"testing"
Expand Down Expand Up @@ -40,22 +43,195 @@ func TestParseAttestationsAggregate(t *testing.T) {
// Verify committee metadata is parsed correctly
metadata := op.Meta()
assert.Len(t, metadata.CommitteeMetadata, 5, "should have 5 committee members in metadata")
assert.Equal(t, 4338, metadata.TotalConsensusPower, "total consensus power should be 4338")
v, err := metadata.TotalConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 4338, v, "total consensus power should be 4338")
_, err = metadata.TotalConsensusPower.AsV024Value()
assert.NotNil(t, err)

// Verify first committee member
assert.Equal(t, tezos.MustParseAddress("tz1NNT9EERmcKekRq2vdv6e8TL3WQpY8AXSF"), metadata.CommitteeMetadata[0].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4X5GCfEHQCUnrBy9Qo1PSsmExYHXxiEkvp"), metadata.CommitteeMetadata[0].ConsensusPkh)
assert.Equal(t, 1435, metadata.CommitteeMetadata[0].ConsensusPower)
v, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 1435, v)
_, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV024Value()
assert.NotNil(t, err)

// Verify second committee member
assert.Equal(t, tezos.MustParseAddress("tz1Zt8QQ9aBznYNk5LUBjtME9DuExomw9YRs"), metadata.CommitteeMetadata[1].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4XbGtqxNZDq6CJNVbxktoqSTu9Db6aXQHL"), metadata.CommitteeMetadata[1].ConsensusPkh)
assert.Equal(t, 1465, metadata.CommitteeMetadata[1].ConsensusPower)
v, err = metadata.CommitteeMetadata[1].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 1465, v)

// Verify tz4 delegate (matching delegate and consensus_pkh)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[2].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[2].ConsensusPkh)
assert.Equal(t, 707, metadata.CommitteeMetadata[2].ConsensusPower)
v, err = metadata.CommitteeMetadata[2].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 707, v)
}

func TestParseAttestationsAggregateV024(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/chains/main/blocks/BKpbfCvh777DQHnXjU2sqHvVUNZ7dBAdqEfKkdw8EGSkD9LSYXb/operations" {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, "Unknown URL: %s", r.URL)
return
}
if r.Header.Get("Accept") != "application/json" {
w.WriteHeader(http.StatusBadRequest)
fmt.Fprintf(w, "Expected Accept: application/json header, got: %s", r.Header.Get("Accept"))
return
}
w.WriteHeader(http.StatusOK)
content := []byte(`[
[
{
"protocol": "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
"chain_id": "NetXd56aBs1aeW3",
"hash": "ooqgVxC8XDYHXSnznWSdkXktgUaA2PZdUs4azRbco9i6fhiY1ui",
"branch": "BKpbfCvh777DQHnXjU2sqHvVUNZ7dBAdqEfKkdw8EGSkD9LSYXb",
"contents": [
{
"kind": "attestations_aggregate",
"consensus_content": {
"level": 109771,
"round": 0,
"block_payload_hash": "vh3RiisbNp7QBvLkJ6HAyoYfMh4AoZLcJFVE5M34LLKnwAWTRv6J"
},
"committee": [
{
"slot": 0,
"dal_attestation": "0"
},
{
"slot": 4,
"dal_attestation": "0"
},
{
"slot": 15
},
{
"slot": 21,
"dal_attestation": "0"
},
{
"slot": 203
}
],
"metadata": {
"committee": [
{
"delegate": "tz1NNT9EERmcKekRq2vdv6e8TL3WQpY8AXSF",
"consensus_pkh": "tz4X5GCfEHQCUnrBy9Qo1PSsmExYHXxiEkvp",
"consensus_power": {
"slots": 1575,
"baking_power": "60261130120715"
}
},
{
"delegate": "tz1Zt8QQ9aBznYNk5LUBjtME9DuExomw9YRs",
"consensus_pkh": "tz4XbGtqxNZDq6CJNVbxktoqSTu9Db6aXQHL",
"consensus_power": {
"slots": 47,
"baking_power": "2038150029478"
}
},
{
"delegate": "tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m",
"consensus_pkh": "tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m",
"consensus_power": {
"slots": 9,
"baking_power": "492207228099"
}
},
{
"delegate": "tz3PgFHdYvEGEbUo1pUJmuNH8fgc8cwARKfC",
"consensus_pkh": "tz4EWkmNN93yE7HrjaRR6mGh22rUgSYJG1Sj",
"consensus_power": {
"slots": 447,
"baking_power": "18010566072999"
}
},
{
"delegate": "tz1LmrwzCKUDibk7xaGC5RxvTbmUbCAtCA4a",
"consensus_pkh": "tz4QqpgVTG4CCETKMgV6YaUHyowE4Gkqwdfi",
"consensus_power": {
"slots": 1,
"baking_power": "6083478248"
}
}
],
"total_consensus_power": {
"slots": 2079,
"baking_power": "80808136929539"
}
}
}
],
"signature": "BLsigB1uDeiiuW1NPKWsZ6WRAKL3aSGTXKmtsDH2xxWgWqM3QBr3mFW8QqzH6VWGsvPGsrii3VVw7KA9CvC9LjC3VxH3MgHSvcWVK6Z7rBbEY79sKXi4XrbbfY8QJpE38B4u6mteGKHnVj"
}
],
[],
[],
[]
]`)
buffer := new(bytes.Buffer)
if err := json.Compact(buffer, content); err != nil {
panic(err)
}
w.Write(buffer.Bytes())
}))
defer server.Close()

c, _ := NewClient(server.URL, nil)
value, e := c.GetBlockOperations(context.TODO(), tezos.MustParseBlockHash("BKpbfCvh777DQHnXjU2sqHvVUNZ7dBAdqEfKkdw8EGSkD9LSYXb"))
assert.Nil(t, e)
assert.Len(t, value, 4)
assert.Len(t, value[0], 1)
assert.Equal(t, value[0][0].Contents.Len(), 1)
op := value[0][0].Contents.N(0).(*AttestationsAggregate)
assert.Equal(t, tezos.OpTypeAttestationsAggregate, op.Kind())
assert.Equal(t, 5, len(op.Committee))
assert.Equal(t, ConsensusContent{Level: 109771, Round: 0, PayloadHash: tezos.MustParsePayloadHash("vh3RiisbNp7QBvLkJ6HAyoYfMh4AoZLcJFVE5M34LLKnwAWTRv6J")}, op.ConsensusContent)

// Verify committee metadata is parsed correctly
metadata := op.Meta()
assert.Len(t, metadata.CommitteeMetadata, 5, "should have 5 committee members in metadata")
v, err := metadata.TotalConsensusPower.AsV024Value()
assert.Nil(t, err)
assert.Equal(t, 2079, v.Slots)
assert.Equal(t, int64(80808136929539), v.BakingPower)
_, err = metadata.TotalConsensusPower.AsV023Value()
assert.NotNil(t, err)

// Verify first committee member
assert.Equal(t, tezos.MustParseAddress("tz1NNT9EERmcKekRq2vdv6e8TL3WQpY8AXSF"), metadata.CommitteeMetadata[0].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4X5GCfEHQCUnrBy9Qo1PSsmExYHXxiEkvp"), metadata.CommitteeMetadata[0].ConsensusPkh)
v, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV024Value()
assert.Nil(t, err)
assert.Equal(t, 1575, v.Slots)
assert.Equal(t, int64(60261130120715), v.BakingPower)
_, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV023Value()
assert.NotNil(t, err)

// Verify second committee member
assert.Equal(t, tezos.MustParseAddress("tz1Zt8QQ9aBznYNk5LUBjtME9DuExomw9YRs"), metadata.CommitteeMetadata[1].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4XbGtqxNZDq6CJNVbxktoqSTu9Db6aXQHL"), metadata.CommitteeMetadata[1].ConsensusPkh)
v, err = metadata.CommitteeMetadata[1].ConsensusPower.AsV024Value()
assert.Nil(t, err)
assert.Equal(t, 47, v.Slots)
assert.Equal(t, int64(2038150029478), v.BakingPower)

// Verify tz4 delegate (matching delegate and consensus_pkh)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[2].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[2].ConsensusPkh)
v, err = metadata.CommitteeMetadata[2].ConsensusPower.AsV024Value()
assert.Nil(t, err)
assert.Equal(t, 9, v.Slots)
assert.Equal(t, int64(492207228099), v.BakingPower)
}

func TestParsePreattestationsAggregate(t *testing.T) {
Expand Down Expand Up @@ -85,17 +261,23 @@ func TestParsePreattestationsAggregate(t *testing.T) {
// Verify committee metadata is parsed correctly
metadata := op.Meta()
assert.Len(t, metadata.CommitteeMetadata, 4, "should have 4 committee members in metadata")
assert.Equal(t, 4371, metadata.TotalConsensusPower, "total consensus power should be 4371")
v, err := metadata.TotalConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 4371, v, "total consensus power should be 4371")

// Verify first committee member
assert.Equal(t, tezos.MustParseAddress("tz1NNT9EERmcKekRq2vdv6e8TL3WQpY8AXSF"), metadata.CommitteeMetadata[0].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4X5GCfEHQCUnrBy9Qo1PSsmExYHXxiEkvp"), metadata.CommitteeMetadata[0].ConsensusPkh)
assert.Equal(t, 1485, metadata.CommitteeMetadata[0].ConsensusPower)
v, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 1485, v)

// Verify tz4 delegate (matching delegate and consensus_pkh)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[1].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[1].ConsensusPkh)
assert.Equal(t, 688, metadata.CommitteeMetadata[1].ConsensusPower)
v, err = metadata.CommitteeMetadata[1].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 688, v)
}

// TestAttestationsAggregateEmptyMetadata tests parsing when metadata fields are absent
Expand All @@ -118,7 +300,72 @@ func TestAttestationsAggregateEmptyMetadata(t *testing.T) {

// Should have empty metadata fields when not provided
assert.Len(t, metadata.CommitteeMetadata, 0, "should have no committee metadata")
assert.Equal(t, 0, metadata.TotalConsensusPower, "total consensus power should be 0")
v, err := metadata.TotalConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 0, v, "total consensus power should be 0")
}

// TestAttestationsAggregateEmptyMetadataV024 tests parsing when metadata fields are absent
func TestAttestationsAggregateEmptyMetadataV024(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(http.StatusOK)
// Response without metadata committee field
content := []byte(`[
[
{
"protocol": "PtTALLiNtPec7mE7yY4m3k26J8Qukef3E3ehzhfXgFZKGtDdAXu",
"chain_id": "NetXd56aBs1aeW3",
"hash": "ooqgVxC8XDYHXSnznWSdkXktgUaA2PZdUs4azRbco9i6fhiY1ui",
"branch": "BLwNFCbHuF21bF4S9KybZd52si5QQG6k29mQTshbY7fVnehrxbh",
"contents": [
{
"kind": "attestations_aggregate",
"consensus_content": {
"level": 109771,
"round": 0,
"block_payload_hash": "vh3RiisbNp7QBvLkJ6HAyoYfMh4AoZLcJFVE5M34LLKnwAWTRv6J"
},
"committee": [
{
"slot": 0,
"dal_attestation": "0"
}
],
"metadata": {

}
}
],
"signature": "BLsigB1uDeiiuW1NPKWsZ6WRAKL3aSGTXKmtsDH2xxWgWqM3QBr3mFW8QqzH6VWGsvPGsrii3VVw7KA9CvC9LjC3VxH3MgHSvcWVK6Z7rBbEY79sKXi4XrbbfY8QJpE38B4u6mteGKHnVj"
}
],
[],
[],
[]
]`)
buffer := new(bytes.Buffer)
if err := json.Compact(buffer, content); err != nil {
panic(err)
}
w.Write(buffer.Bytes())
}))
defer server.Close()

c, _ := NewClient(server.URL, nil)
value, e := c.GetBlockOperations(context.TODO(), tezos.MustParseBlockHash("BMABzWp5Y3iSJRaCkWVwsPKXVZ1iCwB94dB7GfKsigahQ3v5Czc"))
assert.Nil(t, e)
assert.Len(t, value, 4)
assert.Len(t, value[0], 1)

op := value[0][0].Contents.N(0).(*AttestationsAggregate)
metadata := op.Meta()

// Should have empty metadata fields when not provided
assert.Len(t, metadata.CommitteeMetadata, 0, "should have no committee metadata")
v, err := metadata.TotalConsensusPower.AsV024Value()
assert.Nil(t, err)
assert.Equal(t, 0, v.Slots)
assert.Equal(t, int64(0), v.BakingPower)
}

// TestAttestationsAggregateSingleCommitteeMember tests parsing with one committee member
Expand All @@ -137,10 +384,14 @@ func TestAttestationsAggregateSingleCommitteeMember(t *testing.T) {
metadata := op.Meta()

assert.Len(t, metadata.CommitteeMetadata, 1, "should have 1 committee member")
assert.Equal(t, 5000, metadata.TotalConsensusPower)
v, err := metadata.TotalConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 5000, v)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[0].Delegate)
assert.Equal(t, tezos.MustParseAddress("tz4MvCEiLgK6vYRSkug9Nz64UNTbT4McNq8m"), metadata.CommitteeMetadata[0].ConsensusPkh)
assert.Equal(t, 5000, metadata.CommitteeMetadata[0].ConsensusPower)
v, err = metadata.CommitteeMetadata[0].ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, 5000, v)
}

// TestPreattestationsAggregateMetadataConsistency verifies metadata consistency between operations
Expand All @@ -161,14 +412,20 @@ func TestPreattestationsAggregateMetadataConsistency(t *testing.T) {
// Verify the sum of individual consensus powers equals total
sum := 0
for _, member := range metadata.CommitteeMetadata {
sum += member.ConsensusPower
v, err := member.ConsensusPower.AsV023Value()
assert.Nil(t, err, "should not get error while extracting consensus power")
sum += v
}
assert.Equal(t, metadata.TotalConsensusPower, sum, "sum of individual powers should equal total consensus power")
v, err := metadata.TotalConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Equal(t, v, sum, "sum of individual powers should equal total consensus power")

// Verify all addresses are valid Tezos addresses
for i, member := range metadata.CommitteeMetadata {
assert.True(t, member.Delegate.IsValid(), "delegate address at index %d should be valid", i)
assert.True(t, member.ConsensusPkh.IsValid(), "consensus_pkh at index %d should be valid", i)
assert.Greater(t, member.ConsensusPower, 0, "consensus power at index %d should be positive", i)
v, err := member.ConsensusPower.AsV023Value()
assert.Nil(t, err)
assert.Greater(t, v, 0, "consensus power at index %d should be positive", i)
}
}
Loading
Loading