diff --git a/ledger/allegra/pparams.go b/ledger/allegra/pparams.go index fb310e88..74312005 100644 --- a/ledger/allegra/pparams.go +++ b/ledger/allegra/pparams.go @@ -40,6 +40,5 @@ func (u *AllegraProtocolParameterUpdate) UnmarshalCBOR(data []byte) error { } func (p *AllegraProtocolParameters) Utxorpc() *cardano.PParams { - // TODO: Implement the conversion logic to cardano.PParams - return &cardano.PParams{} + return p.ShelleyProtocolParameters.Utxorpc() } diff --git a/ledger/allegra/pparams_test.go b/ledger/allegra/pparams_test.go index d1e196d4..e575446c 100644 --- a/ledger/allegra/pparams_test.go +++ b/ledger/allegra/pparams_test.go @@ -23,6 +23,7 @@ import ( "github.com/blinklabs-io/gouroboros/cbor" "github.com/blinklabs-io/gouroboros/ledger/allegra" "github.com/blinklabs-io/gouroboros/ledger/shelley" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) func TestAllegraProtocolParamsUpdate(t *testing.T) { @@ -78,3 +79,59 @@ func TestAllegraProtocolParamsUpdate(t *testing.T) { } } } + +func TestAllegraUtxorpc(t *testing.T) { + inputParams := allegra.AllegraProtocolParameters{ + ShelleyProtocolParameters: shelley.ShelleyProtocolParameters{ + MinFeeA: 500, + MinFeeB: 2, + MaxBlockBodySize: 65536, + MaxTxSize: 16384, + MaxBlockHeaderSize: 1024, + KeyDeposit: 2000, + PoolDeposit: 500000, + MaxEpoch: 2160, + NOpt: 100, + A0: &cbor.Rat{Rat: big.NewRat(1, 2)}, + Rho: &cbor.Rat{Rat: big.NewRat(3, 4)}, + Tau: &cbor.Rat{Rat: big.NewRat(5, 6)}, + ProtocolMajor: 8, + ProtocolMinor: 0, + MinUtxoValue: 1000000, + }, + } + + expectedUtxorpc := &cardano.PParams{ + MinFeeCoefficient: 500, + MinFeeConstant: 2, + MaxBlockBodySize: 65536, + MaxTxSize: 16384, + MaxBlockHeaderSize: 1024, + StakeKeyDeposit: 2000, + PoolDeposit: 500000, + PoolRetirementEpochBound: 2160, + DesiredNumberOfPools: 100, + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(3), + Denominator: uint32(4), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(5), + Denominator: uint32(6), + }, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: 8, + Minor: 0, + }, + } + + result := inputParams.Utxorpc() + + if !reflect.DeepEqual(result, expectedUtxorpc) { + t.Fatalf("Utxorpc() test failed for Allegra:\nExpected: %#v\nGot: %#v", expectedUtxorpc, result) + } +} diff --git a/ledger/alonzo/pparams.go b/ledger/alonzo/pparams.go index 14074431..804fa8dc 100644 --- a/ledger/alonzo/pparams.go +++ b/ledger/alonzo/pparams.go @@ -113,6 +113,55 @@ func (u *AlonzoProtocolParameterUpdate) UnmarshalCBOR(data []byte) error { } func (p *AlonzoProtocolParameters) Utxorpc() *cardano.PParams { - // TODO: Implement the conversion logic to cardano.PParams - return &cardano.PParams{} + return &cardano.PParams{ + CoinsPerUtxoByte: p.AdaPerUtxoByte, + MaxTxSize: uint64(p.MaxTxSize), + MinFeeCoefficient: uint64(p.MinFeeA), + MinFeeConstant: uint64(p.MinFeeB), + MaxBlockBodySize: uint64(p.MaxBlockBodySize), + MaxBlockHeaderSize: uint64(p.MaxBlockHeaderSize), + StakeKeyDeposit: uint64(p.KeyDeposit), + PoolDeposit: uint64(p.PoolDeposit), + PoolRetirementEpochBound: uint64(p.MaxEpoch), + DesiredNumberOfPools: uint64(p.NOpt), + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(p.A0.Num().Int64()), + Denominator: uint32(p.A0.Denom().Int64()), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Rho.Num().Int64()), + Denominator: uint32(p.Rho.Denom().Int64()), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Tau.Num().Int64()), + Denominator: uint32(p.Tau.Denom().Int64()), + }, + MinPoolCost: p.MinPoolCost, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: uint32(p.ProtocolMajor), + Minor: uint32(p.ProtocolMinor), + }, + MaxValueSize: uint64(p.MaxValueSize), + CollateralPercentage: uint64(p.CollateralPercentage), + MaxCollateralInputs: uint64(p.MaxCollateralInputs), + CostModels: common.ConvertToUtxorpcCardanoCostModels(p.CostModels), + Prices: &cardano.ExPrices{ + Memory: &cardano.RationalNumber{ + Numerator: int32(p.ExecutionCosts.MemPrice.Num().Int64()), + Denominator: uint32(p.ExecutionCosts.MemPrice.Denom().Int64()), + }, + Steps: &cardano.RationalNumber{ + Numerator: int32(p.ExecutionCosts.StepPrice.Num().Int64()), + Denominator: uint32(p.ExecutionCosts.StepPrice.Denom().Int64()), + }, + }, + MaxExecutionUnitsPerTransaction: &cardano.ExUnits{ + Memory: uint64(p.MaxTxExUnits.Mem), + Steps: uint64(p.MaxTxExUnits.Steps), + }, + MaxExecutionUnitsPerBlock: &cardano.ExUnits{ + Memory: uint64(p.MaxBlockExUnits.Mem), + Steps: uint64(p.MaxBlockExUnits.Steps), + }, + } } diff --git a/ledger/alonzo/pparams_test.go b/ledger/alonzo/pparams_test.go index ce2eeec3..4caf5786 100644 --- a/ledger/alonzo/pparams_test.go +++ b/ledger/alonzo/pparams_test.go @@ -27,6 +27,7 @@ import ( "github.com/blinklabs-io/gouroboros/ledger/common" "github.com/blinklabs-io/gouroboros/ledger/mary" "github.com/blinklabs-io/gouroboros/ledger/shelley" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) func TestAlonzoProtocolParamsUpdate(t *testing.T) { @@ -181,3 +182,118 @@ func TestAlonzoProtocolParamsUpdateFromGenesis(t *testing.T) { } } } + +func TestAlonzoUtxorpc(t *testing.T) { + inputParams := alonzo.AlonzoProtocolParameters{ + MaryProtocolParameters: mary.MaryProtocolParameters{ + AllegraProtocolParameters: allegra.AllegraProtocolParameters{ + ShelleyProtocolParameters: shelley.ShelleyProtocolParameters{ + MaxTxSize: 16384, + MinFeeA: 500, + MinFeeB: 2, + MaxBlockBodySize: 65536, + MaxBlockHeaderSize: 1024, + KeyDeposit: 2000, + PoolDeposit: 500000, + MaxEpoch: 2160, + NOpt: 100, + A0: &cbor.Rat{Rat: big.NewRat(1, 2)}, + Rho: &cbor.Rat{Rat: big.NewRat(3, 4)}, + Tau: &cbor.Rat{Rat: big.NewRat(5, 6)}, + ProtocolMajor: 8, + ProtocolMinor: 0, + }, + }, + }, + AdaPerUtxoByte: 44, + MinPoolCost: 340000000, + MaxValueSize: 1024, + CollateralPercentage: 150, + MaxCollateralInputs: 5, + ExecutionCosts: common.ExUnitPrice{ + MemPrice: &cbor.Rat{Rat: big.NewRat(1, 2)}, + StepPrice: &cbor.Rat{Rat: big.NewRat(2, 3)}, + }, + MaxTxExUnits: common.ExUnit{ + Mem: 1000000, + Steps: 200000, + }, + MaxBlockExUnits: common.ExUnit{ + Mem: 5000000, + Steps: 1000000, + }, + CostModels: map[uint][]int64{ + 1: {100, 200, 300}, + 2: {400, 500, 600}, + 3: {700, 800, 900}, + }, + } + + expectedUtxorpc := &cardano.PParams{ + CoinsPerUtxoByte: 44, + MaxTxSize: 16384, + MinFeeCoefficient: 500, + MinFeeConstant: 2, + MaxBlockBodySize: 65536, + MaxBlockHeaderSize: 1024, + StakeKeyDeposit: 2000, + PoolDeposit: 500000, + PoolRetirementEpochBound: 2160, + DesiredNumberOfPools: 100, + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(3), + Denominator: uint32(4), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(5), + Denominator: uint32(6), + }, + MinPoolCost: 340000000, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: 8, + Minor: 0, + }, + MaxValueSize: 1024, + CollateralPercentage: 150, + MaxCollateralInputs: 5, + CostModels: &cardano.CostModels{ + PlutusV1: &cardano.CostModel{ + Values: []int64{100, 200, 300}, + }, + PlutusV2: &cardano.CostModel{ + Values: []int64{400, 500, 600}, + }, + PlutusV3: &cardano.CostModel{ + Values: []int64{700, 800, 900}, + }, + }, + Prices: &cardano.ExPrices{ + Memory: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + Steps: &cardano.RationalNumber{ + Numerator: int32(2), + Denominator: uint32(3), + }, + }, + MaxExecutionUnitsPerTransaction: &cardano.ExUnits{ + Memory: 1000000, + Steps: 200000, + }, + MaxExecutionUnitsPerBlock: &cardano.ExUnits{ + Memory: 5000000, + Steps: 1000000, + }, + } + + result := inputParams.Utxorpc() + + if !reflect.DeepEqual(result, expectedUtxorpc) { + t.Fatalf("Utxorpc() test failed for Alonzo:\nExpected: %#v\nGot: %#v", expectedUtxorpc, result) + } +} diff --git a/ledger/babbage/pparams.go b/ledger/babbage/pparams.go index 4913d25d..431be1c9 100644 --- a/ledger/babbage/pparams.go +++ b/ledger/babbage/pparams.go @@ -153,6 +153,57 @@ func (u *BabbageProtocolParameterUpdate) UnmarshalCBOR(data []byte) error { } func (p *BabbageProtocolParameters) Utxorpc() *cardano.PParams { - // TODO: Implement the conversion logic to cardano.PParams - return &cardano.PParams{} + return &cardano.PParams{ + CoinsPerUtxoByte: p.AdaPerUtxoByte, + MaxTxSize: uint64(p.MaxTxSize), + MinFeeCoefficient: uint64(p.MinFeeA), + MinFeeConstant: uint64(p.MinFeeB), + MaxBlockBodySize: uint64(p.MaxBlockBodySize), + MaxBlockHeaderSize: uint64(p.MaxBlockHeaderSize), + StakeKeyDeposit: uint64(p.KeyDeposit), + PoolDeposit: uint64(p.PoolDeposit), + PoolRetirementEpochBound: uint64(p.MaxEpoch), + DesiredNumberOfPools: uint64(p.NOpt), + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(p.A0.Num().Int64()), + Denominator: uint32(p.A0.Denom().Int64()), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Rho.Num().Int64()), + Denominator: uint32(p.Rho.Denom().Int64()), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Tau.Num().Int64()), + Denominator: uint32(p.Tau.Denom().Int64()), + }, + MinPoolCost: p.MinPoolCost, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: uint32(p.ProtocolMajor), + Minor: uint32(p.ProtocolMinor), + }, + MaxValueSize: uint64(p.MaxValueSize), + CollateralPercentage: uint64(p.CollateralPercentage), + MaxCollateralInputs: uint64(p.MaxCollateralInputs), + CostModels: common.ConvertToUtxorpcCardanoCostModels( + p.CostModels, + ), + Prices: &cardano.ExPrices{ + Memory: &cardano.RationalNumber{ + Numerator: int32(p.ExecutionCosts.MemPrice.Num().Int64()), + Denominator: uint32(p.ExecutionCosts.MemPrice.Denom().Int64()), + }, + Steps: &cardano.RationalNumber{ + Numerator: int32(p.ExecutionCosts.StepPrice.Num().Int64()), + Denominator: uint32(p.ExecutionCosts.StepPrice.Denom().Int64()), + }, + }, + MaxExecutionUnitsPerTransaction: &cardano.ExUnits{ + Memory: uint64(p.MaxTxExUnits.Mem), + Steps: uint64(p.MaxTxExUnits.Steps), + }, + MaxExecutionUnitsPerBlock: &cardano.ExUnits{ + Memory: uint64(p.MaxBlockExUnits.Mem), + Steps: uint64(p.MaxBlockExUnits.Steps), + }, + } } diff --git a/ledger/babbage/pparams_test.go b/ledger/babbage/pparams_test.go index d9dc30d1..25262784 100644 --- a/ledger/babbage/pparams_test.go +++ b/ledger/babbage/pparams_test.go @@ -16,12 +16,14 @@ package babbage_test import ( "encoding/hex" + "math/big" "reflect" "testing" "github.com/blinklabs-io/gouroboros/cbor" "github.com/blinklabs-io/gouroboros/ledger/babbage" "github.com/blinklabs-io/gouroboros/ledger/common" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) func TestBabbageProtocolParamsUpdate(t *testing.T) { @@ -430,3 +432,123 @@ func TestBabbageProtocolParamsUpdate(t *testing.T) { } } } + +func TestBabbageUtxorpc(t *testing.T) { + testDefs := []struct { + startParams babbage.BabbageProtocolParameters + expectedUtxorpc *cardano.PParams + }{ + { + startParams: babbage.BabbageProtocolParameters{ + AdaPerUtxoByte: 44, + MaxTxSize: 16384, + MinFeeA: 500, + MinFeeB: 2, + MaxBlockBodySize: 65536, + MaxBlockHeaderSize: 1024, + KeyDeposit: 2000, + PoolDeposit: 500000, + MaxEpoch: 2160, + NOpt: 100, + A0: &cbor.Rat{Rat: big.NewRat(1, 2)}, + Rho: &cbor.Rat{Rat: big.NewRat(3, 4)}, + Tau: &cbor.Rat{Rat: big.NewRat(5, 6)}, + MinPoolCost: 340000000, + ProtocolMajor: 8, + ProtocolMinor: 0, + MaxValueSize: 1024, + CollateralPercentage: 150, + MaxCollateralInputs: 5, + ExecutionCosts: common.ExUnitPrice{ + MemPrice: &cbor.Rat{Rat: big.NewRat(1, 2)}, + StepPrice: &cbor.Rat{Rat: big.NewRat(2, 3)}, + }, + MaxTxExUnits: common.ExUnit{ + Mem: 1000000, + Steps: 200000, + }, + MaxBlockExUnits: common.ExUnit{ + Mem: 5000000, + Steps: 1000000, + }, + CostModels: map[uint][]int64{ + 1: {100, 200, 300}, + 2: {400, 500, 600}, + 3: {700, 800, 900}, + }, + }, + expectedUtxorpc: &cardano.PParams{ + CoinsPerUtxoByte: 44, + MaxTxSize: 16384, + MinFeeCoefficient: 500, + MinFeeConstant: 2, + MaxBlockBodySize: 65536, + MaxBlockHeaderSize: 1024, + StakeKeyDeposit: 2000, + PoolDeposit: 500000, + PoolRetirementEpochBound: 2160, + DesiredNumberOfPools: 100, + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(3), + Denominator: uint32(4), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(5), + Denominator: uint32(6), + }, + MinPoolCost: 340000000, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: 8, + Minor: 0, + }, + MaxValueSize: 1024, + CollateralPercentage: 150, + MaxCollateralInputs: 5, + CostModels: &cardano.CostModels{ + PlutusV1: &cardano.CostModel{ + Values: []int64{100, 200, 300}, + }, + PlutusV2: &cardano.CostModel{ + Values: []int64{400, 500, 600}, + }, + PlutusV3: &cardano.CostModel{ + Values: []int64{700, 800, 900}, + }, + }, + Prices: &cardano.ExPrices{ + Memory: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + Steps: &cardano.RationalNumber{ + Numerator: int32(2), + Denominator: uint32(3), + }, + }, + MaxExecutionUnitsPerTransaction: &cardano.ExUnits{ + Memory: 1000000, + Steps: 200000, + }, + MaxExecutionUnitsPerBlock: &cardano.ExUnits{ + Memory: 5000000, + Steps: 1000000, + }, + }, + }, + } + + for _, testDef := range testDefs { + result := testDef.startParams.Utxorpc() + if !reflect.DeepEqual(result, testDef.expectedUtxorpc) { + t.Fatalf( + "Utxorpc() test failed:\nExpected: %#v\nGot: %#v", + testDef.expectedUtxorpc, + result, + ) + } + } +} diff --git a/ledger/mary/pparams.go b/ledger/mary/pparams.go index c61f4b37..bfd26ae1 100644 --- a/ledger/mary/pparams.go +++ b/ledger/mary/pparams.go @@ -14,7 +14,10 @@ package mary -import "github.com/blinklabs-io/gouroboros/ledger/allegra" +import ( + "github.com/blinklabs-io/gouroboros/ledger/allegra" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" +) type MaryProtocolParameters struct { allegra.AllegraProtocolParameters @@ -35,3 +38,7 @@ type MaryProtocolParameterUpdate struct { func (u *MaryProtocolParameterUpdate) UnmarshalCBOR(data []byte) error { return u.UnmarshalCbor(data, u) } + +func (p *MaryProtocolParameters) Utxorpc() *cardano.PParams { + return p.AllegraProtocolParameters.Utxorpc() +} diff --git a/ledger/mary/pparams_test.go b/ledger/mary/pparams_test.go index 76fb1e1a..aa096824 100644 --- a/ledger/mary/pparams_test.go +++ b/ledger/mary/pparams_test.go @@ -24,6 +24,7 @@ import ( "github.com/blinklabs-io/gouroboros/ledger/allegra" "github.com/blinklabs-io/gouroboros/ledger/mary" "github.com/blinklabs-io/gouroboros/ledger/shelley" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) func TestMaryProtocolParamsUpdate(t *testing.T) { @@ -89,3 +90,61 @@ func TestMaryProtocolParamsUpdate(t *testing.T) { } } } + +func TestMaryUtxorpc(t *testing.T) { + inputParams := mary.MaryProtocolParameters{ + AllegraProtocolParameters: allegra.AllegraProtocolParameters{ + ShelleyProtocolParameters: shelley.ShelleyProtocolParameters{ + MinFeeA: 500, + MinFeeB: 2, + MaxBlockBodySize: 65536, + MaxTxSize: 16384, + MaxBlockHeaderSize: 1024, + KeyDeposit: 2000, + PoolDeposit: 500000, + MaxEpoch: 2160, + NOpt: 100, + A0: &cbor.Rat{Rat: big.NewRat(1, 2)}, + Rho: &cbor.Rat{Rat: big.NewRat(3, 4)}, + Tau: &cbor.Rat{Rat: big.NewRat(5, 6)}, + ProtocolMajor: 8, + ProtocolMinor: 0, + MinUtxoValue: 1000000, + }, + }, + } + + expectedUtxorpc := &cardano.PParams{ + MinFeeCoefficient: 500, + MinFeeConstant: 2, + MaxBlockBodySize: 65536, + MaxTxSize: 16384, + MaxBlockHeaderSize: 1024, + StakeKeyDeposit: 2000, + PoolDeposit: 500000, + PoolRetirementEpochBound: 2160, + DesiredNumberOfPools: 100, + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(3), + Denominator: uint32(4), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(5), + Denominator: uint32(6), + }, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: 8, + Minor: 0, + }, + } + + result := inputParams.Utxorpc() + + if !reflect.DeepEqual(result, expectedUtxorpc) { + t.Fatalf("Utxorpc() test failed for Mary:\nExpected: %#v\nGot: %#v", expectedUtxorpc, result) + } +} diff --git a/ledger/shelley/pparams.go b/ledger/shelley/pparams.go index 7da9fd15..12722f0a 100644 --- a/ledger/shelley/pparams.go +++ b/ledger/shelley/pparams.go @@ -19,6 +19,7 @@ import ( "github.com/blinklabs-io/gouroboros/cbor" "github.com/blinklabs-io/gouroboros/ledger/common" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) type ShelleyProtocolParameters struct { @@ -153,3 +154,33 @@ func (ShelleyProtocolParameterUpdate) IsProtocolParameterUpdate() {} func (u *ShelleyProtocolParameterUpdate) UnmarshalCBOR(data []byte) error { return u.UnmarshalCbor(data, u) } + +func (p *ShelleyProtocolParameters) Utxorpc() *cardano.PParams { + return &cardano.PParams{ + MaxTxSize: uint64(p.MaxTxSize), + MinFeeCoefficient: uint64(p.MinFeeA), + MinFeeConstant: uint64(p.MinFeeB), + MaxBlockBodySize: uint64(p.MaxBlockBodySize), + MaxBlockHeaderSize: uint64(p.MaxBlockHeaderSize), + StakeKeyDeposit: uint64(p.KeyDeposit), + PoolDeposit: uint64(p.PoolDeposit), + PoolRetirementEpochBound: uint64(p.MaxEpoch), + DesiredNumberOfPools: uint64(p.NOpt), + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(p.A0.Num().Int64()), + Denominator: uint32(p.A0.Denom().Int64()), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Rho.Num().Int64()), + Denominator: uint32(p.Rho.Denom().Int64()), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(p.Tau.Num().Int64()), + Denominator: uint32(p.Tau.Denom().Int64()), + }, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: uint32(p.ProtocolMajor), + Minor: uint32(p.ProtocolMinor), + }, + } +} diff --git a/ledger/shelley/pparams_test.go b/ledger/shelley/pparams_test.go index e576d610..aba6c5ea 100644 --- a/ledger/shelley/pparams_test.go +++ b/ledger/shelley/pparams_test.go @@ -23,6 +23,7 @@ import ( "github.com/blinklabs-io/gouroboros/cbor" "github.com/blinklabs-io/gouroboros/ledger/shelley" + "github.com/utxorpc/go-codegen/utxorpc/v1alpha/cardano" ) func TestShelleyProtocolParamsUpdate(t *testing.T) { @@ -103,3 +104,56 @@ func TestShelleyProtocolParamsUpdateFromGenesis(t *testing.T) { } } } + +func TestShelleyUtxorpc(t *testing.T) { + inputParams := shelley.ShelleyProtocolParameters{ + MinFeeA: 500, + MinFeeB: 2, + MaxBlockBodySize: 65536, + MaxTxSize: 16384, + MaxBlockHeaderSize: 1024, + KeyDeposit: 2000, + PoolDeposit: 500000, + MaxEpoch: 2160, + NOpt: 100, + A0: &cbor.Rat{Rat: big.NewRat(1, 2)}, + Rho: &cbor.Rat{Rat: big.NewRat(3, 4)}, + Tau: &cbor.Rat{Rat: big.NewRat(5, 6)}, + ProtocolMajor: 8, + ProtocolMinor: 0, + } + + expectedUtxorpc := &cardano.PParams{ + MaxTxSize: 16384, + MinFeeCoefficient: 500, + MinFeeConstant: 2, + MaxBlockBodySize: 65536, + MaxBlockHeaderSize: 1024, + StakeKeyDeposit: 2000, + PoolDeposit: 500000, + PoolRetirementEpochBound: 2160, + DesiredNumberOfPools: 100, + PoolInfluence: &cardano.RationalNumber{ + Numerator: int32(1), + Denominator: uint32(2), + }, + MonetaryExpansion: &cardano.RationalNumber{ + Numerator: int32(3), + Denominator: uint32(4), + }, + TreasuryExpansion: &cardano.RationalNumber{ + Numerator: int32(5), + Denominator: uint32(6), + }, + ProtocolVersion: &cardano.ProtocolVersion{ + Major: 8, + Minor: 0, + }, + } + + result := inputParams.Utxorpc() + + if !reflect.DeepEqual(result, expectedUtxorpc) { + t.Fatalf("Utxorpc() test failed for Shelley:\nExpected: %#v\nGot: %#v", expectedUtxorpc, result) + } +}