From 966601da7e121d32d8a34e1267518e2e40ae538c Mon Sep 17 00:00:00 2001 From: Sotatek-HuyLe3a Date: Tue, 19 Mar 2024 09:37:15 +0700 Subject: [PATCH 1/4] chore: #147 enable governance store --- application/build.gradle | 1 + .../V1_1_6__add-conway-param-columns.sql | 47 +++++++++++++++++++ gradle/libs.versions.toml | 1 + 3 files changed, 49 insertions(+) create mode 100644 application/src/main/resources/db/migration/ledgersync/V1_1_6__add-conway-param-columns.sql diff --git a/application/build.gradle b/application/build.gradle index e7e27035..2f67dd72 100644 --- a/application/build.gradle +++ b/application/build.gradle @@ -19,6 +19,7 @@ dependencies { implementation project(':components:scheduler') implementation(libs.yaci.store.starter) + implementation(libs.yaci.store.governance.starter) implementation(libs.cardano.client.lib) diff --git a/application/src/main/resources/db/migration/ledgersync/V1_1_6__add-conway-param-columns.sql b/application/src/main/resources/db/migration/ledgersync/V1_1_6__add-conway-param-columns.sql new file mode 100644 index 00000000..5a64cbd0 --- /dev/null +++ b/application/src/main/resources/db/migration/ledgersync/V1_1_6__add-conway-param-columns.sql @@ -0,0 +1,47 @@ +ALTER TABLE epoch_param + ADD COLUMN pvt_motion_no_confidence double precision, + ADD COLUMN pvt_commit_normal double precision, + ADD COLUMN pvt_committee_no_confidence double precision, + ADD COLUMN pvt_hard_fork_initiation double precision, + ADD COLUMN pvt_p_p_security_group double precision, + ADD COLUMN pvt_p_p_technical_group double precision, + ADD COLUMN pvt_p_p_gov_group double precision, + ADD COLUMN pvt_treasury_withdrawal double precision, + ADD COLUMN dvt_motion_no_confidence double precision, + ADD COLUMN dvt_commitee_normal double precision, + ADD COLUMN dvt_committee_no_confidence double precision, + ADD COLUMN dvt_update_to_constitution double precision, + ADD COLUMN dvt_hard_fork_initiation double precision, + ADD COLUMN dvt_p_p_network_group double precision, + ADD COLUMN dvt_p_p_economic_group double precision, + ADD COLUMN committee_min_size numeric(20, 0), + ADD COLUMN committee_max_term_length numeric(20, 0), + ADD COLUMN gov_action_lifetime numeric(20, 0), + ADD COLUMN gov_action_deposit numeric(20, 0), + ADD COLUMN drep_deposit numeric(20, 0), + ADD COLUMN drep_activity numeric(20, 0), + ADD COLUMN min_fee_ref_script_cost_per_byte numeric(20, 0); + +ALTER TABLE param_proposal + ADD COLUMN pvt_motion_no_confidence double precision, + ADD COLUMN pvt_commit_normal double precision, + ADD COLUMN pvt_committee_no_confidence double precision, + ADD COLUMN pvt_hard_fork_initiation double precision, + ADD COLUMN pvt_p_p_security_group double precision, + ADD COLUMN pvt_p_p_technical_group double precision, + ADD COLUMN pvt_p_p_gov_group double precision, + ADD COLUMN pvt_treasury_withdrawal double precision, + ADD COLUMN dvt_motion_no_confidence double precision, + ADD COLUMN dvt_commitee_normal double precision, + ADD COLUMN dvt_committee_no_confidence double precision, + ADD COLUMN dvt_update_to_constitution double precision, + ADD COLUMN dvt_hard_fork_initiation double precision, + ADD COLUMN dvt_p_p_network_group double precision, + ADD COLUMN dvt_p_p_economic_group double precision, + ADD COLUMN committee_min_size numeric(20, 0), + ADD COLUMN committee_max_term_length numeric(20, 0), + ADD COLUMN gov_action_lifetime numeric(20, 0), + ADD COLUMN gov_action_deposit numeric(20, 0), + ADD COLUMN drep_deposit numeric(20, 0), + ADD COLUMN drep_activity numeric(20, 0), + ADD COLUMN min_fee_ref_script_cost_per_byte numeric(20, 0); diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml index f285f67f..64773ebf 100644 --- a/gradle/libs.versions.toml +++ b/gradle/libs.versions.toml @@ -2,6 +2,7 @@ yaci-store-starter="com.bloxbean.cardano:yaci-store-spring-boot-starter:0.1.0-rc2-d5f2998-SNAPSHOT" yaci-store-utxo-starter="com.bloxbean.cardano:yaci-store-utxo-spring-boot-starter:0.1.0-rc2-d5f2998-SNAPSHOT" yaci-store-account-starter="com.bloxbean.cardano:yaci-store-account-spring-boot-starter:0.1.0-rc2-d5f2998-SNAPSHOT" +yaci-store-governance-starter="com.bloxbean.cardano:yaci-store-governance-spring-boot-starter:0.1.0-rc2-d5f2998-SNAPSHOT" yaci-store-remote-starter="com.bloxbean.cardano:yaci-store-remote-spring-boot-starter:0.1.0-rc2-d5f2998-SNAPSHOT" cardano-client-lib="com.bloxbean.cardano:cardano-client-lib:0.5.1" From a43f0c16cdb7da9a98c345cd42cdc907c5c80b3d Mon Sep 17 00:00:00 2001 From: Sotatek-HuyLe3a Date: Tue, 19 Mar 2024 09:43:59 +0700 Subject: [PATCH 2/4] feat: #147 update conway genesis file and add new conway params --- .../ledgersync/dto/GenesisData.java | 1 + .../ledgersync/service/EpochParamService.java | 2 + .../service/impl/EpochParamServiceImpl.java | 10 ++ .../impl/ParamProposalServiceImpl.java | 74 ++++++++++++++ .../impl/genesis/GenesisDataServiceImpl.java | 81 +++++++++++++++- .../networks/mainnet/conway-genesis.json | 39 +++++++- .../networks/preprod/conway-genesis.json | 37 ++++++- .../networks/preview/conway-genesis.json | 39 +++++++- .../networks/sanchonet/conway-genesis.json | 41 ++++---- .../consumercommon/entity/EpochParam.java | 91 ++++++++++++++++- .../consumercommon/entity/ParamProposal.java | 97 ++++++++++++++++++- 11 files changed, 483 insertions(+), 29 deletions(-) diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/dto/GenesisData.java b/application/src/main/java/org/cardanofoundation/ledgersync/dto/GenesisData.java index fb437df3..ad75bed8 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/dto/GenesisData.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/dto/GenesisData.java @@ -24,5 +24,6 @@ public class GenesisData { EpochParam shelley; EpochParam alonzo; EpochParam babbage; + EpochParam conway; Timestamp startTime; } diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/EpochParamService.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/EpochParamService.java index 4b83e030..627b19b3 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/EpochParamService.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/EpochParamService.java @@ -11,6 +11,8 @@ public interface EpochParamService { void setDefBabbageEpochParam(EpochParam defBabbageEpochParam); + void setDefConwayEpochParam(EpochParam defConwayEpochParam); + /** * Handle epoch params */ diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImpl.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImpl.java index 2598e5ec..bb4e6ed8 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImpl.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImpl.java @@ -40,6 +40,7 @@ public class EpochParamServiceImpl implements EpochParamService { EpochParam defShelleyEpochParam; EpochParam defAlonzoEpochParam; EpochParam defBabbageEpochParam; + EpochParam defConwayEpochParam; public EpochParamServiceImpl(BlockRepository blockRepository, ParamProposalRepository paramProposalRepository, EpochParamRepository epochParamRepository, EpochRepository epochRepository, @@ -70,6 +71,11 @@ public void setDefBabbageEpochParam(EpochParam defBabbageEpochParam) { this.defBabbageEpochParam = defBabbageEpochParam; } + @Override + public void setDefConwayEpochParam(EpochParam defConwayEpochParam) { + this.defConwayEpochParam = defConwayEpochParam; + } + @Override public void handleEpochParams() { Integer lastEpochParam = epochParamRepository.findLastEpochParam() @@ -126,6 +132,10 @@ void handleEpochParam(int epochNo) { epochParamMapper.updateByEpochParam(curEpochParam, defBabbageEpochParam); } + if (curEra == EraType.CONWAY && prevEra == EraType.BABBAGE) { + epochParamMapper.updateByEpochParam(curEpochParam, defConwayEpochParam); + } + List prevParamProposals = paramProposalRepository .findParamProposalsByEpochNo(epochNo - 1); diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java index 557726f8..0476520a 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java @@ -106,6 +106,57 @@ private List handleParamProposal(AggregatedTx aggregatedTx, Tx tx var collateralPercent = protocolParamUpdate.getCollateralPercent(); var maxCollateralInputs = protocolParamUpdate.getMaxCollateralInputs(); + // conway era params + var poolVotingThresholds = protocolParamUpdate.getPoolVotingThresholds(); + + Double pvtMotionNoConfidence = null; + Double pvtCommitteeNormal = null; + Double pvtCommitteeNoConfidence = null; + Double pvtHardForkInitiation = null; + Double pvtPPSecurityGroup = null; + + if (poolVotingThresholds != null) { + pvtMotionNoConfidence = toDouble(poolVotingThresholds.getPvtMotionNoConfidence()); + pvtCommitteeNormal = toDouble(poolVotingThresholds.getPvtCommitteeNormal()); + pvtCommitteeNoConfidence = toDouble(poolVotingThresholds.getPvtCommitteeNoConfidence()); + pvtHardForkInitiation = toDouble(poolVotingThresholds.getPvtHardForkInitiation()); + pvtPPSecurityGroup = toDouble(poolVotingThresholds.getPvtPPSecurityGroup()); + } + + var drepVotingThresholds = protocolParamUpdate.getDrepVotingThresholds(); + + Double dvtMotionNoConfidence = null; + Double dvtCommitteeNormal = null; + Double dvtCommitteeNoConfidence = null; + Double dvtUpdateToConstitution = null; + Double dvtHardForkInitiation = null; + Double dvtPPNetworkGroup = null; + Double dvtPPEconomicGroup = null; + Double dvtPPTechnicalGroup = null; + Double dvtPPGovGroup = null; + Double dvtTreasuryWithdrawal = null; + + if (drepVotingThresholds != null) { + dvtMotionNoConfidence = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtCommitteeNormal = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtCommitteeNoConfidence = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtUpdateToConstitution = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtHardForkInitiation = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtPPNetworkGroup = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtPPEconomicGroup = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtPPTechnicalGroup = toDouble(drepVotingThresholds.getDvtPPTechnicalGroup()); + dvtPPGovGroup = toDouble(drepVotingThresholds.getDvtPPGovGroup()); + dvtTreasuryWithdrawal = toDouble(drepVotingThresholds.getDvtTreasuryWithdrawal()); + } + + var committeeMinSize = toBigInteger(protocolParamUpdate.getCommitteeMinSize()); + var committeeMaxTermLength = toBigInteger(protocolParamUpdate.getCommitteeMaxTermLength()); + var govActionLifetime = toBigInteger(protocolParamUpdate.getGovActionLifetime()); + var govActionDeposit = protocolParamUpdate.getGovActionDeposit(); + var drepDeposit = protocolParamUpdate.getDrepDeposit(); + var drepActivity = toBigInteger(protocolParamUpdate.getDrepActivity()); + var minFeeRefScriptCostPerByte = toBigInteger(protocolParamUpdate.getMinFeeRefScriptCostPerByte()); + return ParamProposal.builder() .key(entrySet.getKey()) .epochNo(epochNo) @@ -139,6 +190,29 @@ private List handleParamProposal(AggregatedTx aggregatedTx, Tx tx .collateralPercent(collateralPercent) .maxCollateralInputs(maxCollateralInputs) .registeredTx(tx) + // conway era params + .pvtMotionNoConfidence(pvtMotionNoConfidence) + .pvtCommitteeNormal(pvtCommitteeNormal) + .pvtCommitteeNoConfidence(pvtCommitteeNoConfidence) + .pvtHardForkInitiation(pvtHardForkInitiation) + .pvtPPSecurityGroup(pvtPPSecurityGroup) + .dvtMotionNoConfidence(dvtMotionNoConfidence) + .dvtCommitteeNormal(dvtCommitteeNormal) + .dvtCommitteeNoConfidence(dvtCommitteeNoConfidence) + .dvtUpdateToConstitution(dvtUpdateToConstitution) + .dvtHardForkInitiation(dvtHardForkInitiation) + .dvtPPNetworkGroup(dvtPPNetworkGroup) + .dvtPPEconomicGroup(dvtPPEconomicGroup) + .dvtPPTechnicalGroup(dvtPPTechnicalGroup) + .dvtPPGovGroup(dvtPPGovGroup) + .dvtTreasuryWithdrawal(dvtTreasuryWithdrawal) + .committeeMinSize(committeeMinSize) + .committeeMaxTermLength(committeeMaxTermLength) + .govActionLifetime(govActionLifetime) + .govActionDeposit(govActionDeposit) + .drepDeposit(drepDeposit) + .drepActivity(drepActivity) + .minFeeRefScriptCostPerByte(minFeeRefScriptCostPerByte) .build(); }).collect(Collectors.toList()); diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java index aa7273f7..a9736b1e 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java @@ -88,6 +88,40 @@ public class GenesisDataServiceImpl implements GenesisDataService { public static final String UPDATE_QUORUM = "updateQuorum"; public static final String DELEGATION_KEYS = "genDelegs"; + private final static String POOL_VOTING_THRESHOLDS = "poolVotingThresholds"; + private final static String COMMITTEE_NORMAL = "committeeNormal"; + private final static String COMMITTEE_NO_CONFIDENCE = "committeeNoConfidence"; + private final static String HARD_FORK_INITIATION = "hardForkInitiation"; + private final static String MOTION_NO_CONFIDENCE = "motionNoConfidence"; + private final static String PP_SECURITY_GROUP = "ppSecurityGroup"; + private final static String D_REP_VOTING_THRESHOLDS = "dRepVotingThresholds"; + private final static String MOTION_NO_CONFIDENCE1 = "motionNoConfidence"; + private final static String COMMITTEE_NORMAL1 = "committeeNormal"; + private final static String COMMITTEE_NO_CONFIDENCE1 = "committeeNoConfidence"; + private final static String UPDATE_TO_CONSTITUTION = "updateToConstitution"; + private final static String HARD_FORK_INITIATION1 = "hardForkInitiation"; + private final static String PP_NETWORK_GROUP = "ppNetworkGroup"; + private final static String PP_ECONOMIC_GROUP = "ppEconomicGroup"; + private final static String PP_TECHNICAL_GROUP = "ppTechnicalGroup"; + private final static String PP_GOV_GROUP = "ppGovGroup"; + private final static String TREASURY_WITHDRAWAL = "treasuryWithdrawal"; + + private final static String COMMITTEE_MIN_SIZE = "committeeMinSize"; + private final static String COMMITTEE_MAX_TERM_LENGTH = "committeeMaxTermLength"; + private final static String GOV_ACTION_LIFETIME = "govActionLifetime"; + private final static String GOV_ACTION_DEPOSIT = "govActionDeposit"; + private final static String D_REP_DEPOSIT = "dRepDeposit"; + private final static String D_REP_ACTIVITY = "dRepActivity"; + + private final static String CONSTITUTION = "constitution"; + private final static String ANCHOR = "anchor"; + private final static String URL = "url"; + private final static String DATA_HASH = "dataHash"; + + private final static String COMMITTEE = "committee"; + private final static String MEMBERS = "members"; + private final static String QUORUM = "quorum"; + @Value("${genesis.byron}") String genesisByron; @@ -128,6 +162,7 @@ void init(){ fetchShelleyGenesis(genesisData); fetchAlonzoGenesis(genesisData); setupBabbageGenesis(genesisData); + fetchConwayGenesis(genesisData); log.info("setup shelley genesis"); epochParamService.setDefShelleyEpochParam(genesisData.getShelley()); @@ -135,6 +170,8 @@ void init(){ epochParamService.setDefAlonzoEpochParam(genesisData.getAlonzo()); log.info("setup babbage genesis"); epochParamService.setDefBabbageEpochParam(genesisData.getBabbage()); + log.info("setup conway genesis"); + epochParamService.setDefConwayEpochParam(genesisData.getConway()); log.info("setup genesis cost model"); costModelService.setGenesisCostModel(genesisData.getCostModel()); } @@ -330,6 +367,49 @@ public void setupBabbageGenesis(GenesisData genesisData) { genesisData.setBabbage(genesisShelleyProtocols); } + public void fetchConwayGenesis(GenesisData genesisData) { + log.info("Fetch block from url {}", genesisConway); + String genesisConwayJson = genesisFetching.getContent(genesisConway); + + try { + Map genesisConwayJsonMap = objectMapper.readValue(genesisConwayJson, + new TypeReference<>() { + }); + final var poolVotingThresholds = (Map) genesisConwayJsonMap.get(POOL_VOTING_THRESHOLDS); + final var dRepVotingThresholds = (Map) genesisConwayJsonMap.get(D_REP_VOTING_THRESHOLDS); + + EpochParam genesisShelleyProtocols = EpochParam.builder() + .pvtCommitteeNormal(convertObjectToBigDecimal(poolVotingThresholds.get(COMMITTEE_NORMAL)).doubleValue()) + .pvtCommitteeNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(COMMITTEE_NO_CONFIDENCE)).doubleValue()) + .pvtHardForkInitiation(convertObjectToBigDecimal(poolVotingThresholds.get(HARD_FORK_INITIATION)).doubleValue()) + .pvtMotionNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .pvtPPSecurityGroup(convertObjectToBigDecimal(poolVotingThresholds.get(PP_SECURITY_GROUP)).doubleValue()) + .dvtMotionNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE1)).doubleValue()) + .dvtCommitteeNormal(convertObjectToBigDecimal(dRepVotingThresholds.get(COMMITTEE_NORMAL1)).doubleValue()) + .dvtCommitteeNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(COMMITTEE_NO_CONFIDENCE1)).doubleValue()) + .dvtUpdateToConstitution(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtHardForkInitiation(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtPPNetworkGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtPPEconomicGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtPPTechnicalGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtPPGovGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtTreasuryWithdrawal(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .committeeMinSize(convertObjecToBigInteger(genesisConwayJsonMap.get(COMMITTEE_MIN_SIZE))) + .committeeMaxTermLength(convertObjecToBigInteger(genesisConwayJsonMap.get(COMMITTEE_MAX_TERM_LENGTH))) + .govActionLifetime(convertObjecToBigInteger(genesisConwayJsonMap.get(GOV_ACTION_LIFETIME))) + .govActionDeposit(convertObjecToBigInteger(genesisConwayJsonMap.get(GOV_ACTION_DEPOSIT))) + .drepDeposit(convertObjecToBigInteger(genesisConwayJsonMap.get(D_REP_DEPOSIT))) + .drepActivity(convertObjecToBigInteger(genesisConwayJsonMap.get(D_REP_ACTIVITY))) + .build(); + + genesisData.setConway(genesisShelleyProtocols); + } catch (Exception e) { + log.error("Genesis data at {} can't parse from json to java object", genesisConway); + log.error("{} value \n {}", genesisAlonzo, genesisConwayJson); + log.error("{}", e.getMessage()); + System.exit(0); + } + } /** * Fetching data from alonzo-genesis.json link extracting and mapping protocol parameters in * alonzo era @@ -443,7 +523,6 @@ public void fetchShelleyGenesis(GenesisData genesisData) { System.exit(0); } } - /** * Read genesis hash from config.json */ diff --git a/application/src/main/resources/networks/mainnet/conway-genesis.json b/application/src/main/resources/networks/mainnet/conway-genesis.json index 4525ef4a..e690f455 100644 --- a/application/src/main/resources/networks/mainnet/conway-genesis.json +++ b/application/src/main/resources/networks/mainnet/conway-genesis.json @@ -1,3 +1,38 @@ { - "genDelegs": {} -} + "poolVotingThresholds": { + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "hardForkInitiation": 0.51, + "motionNoConfidence": 0.51, + "ppSecurityGroup": 0.51 + }, + "dRepVotingThresholds": { + "motionNoConfidence": 0.51, + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "updateToConstitution": 0.51, + "hardForkInitiation": 0.51, + "ppNetworkGroup": 0.51, + "ppEconomicGroup": 0.51, + "ppTechnicalGroup": 0.51, + "ppGovGroup": 0.51, + "treasuryWithdrawal": 0.51 + }, + "committeeMinSize": 0, + "committeeMaxTermLength": 200, + "govActionLifetime": 10, + "govActionDeposit": 1000000000, + "dRepDeposit": 2000000, + "dRepActivity": 20, + "constitution": { + "anchor": { + "url": "", + "dataHash": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + "committee": { + "members": { + }, + "quorum": 0 + } +} \ No newline at end of file diff --git a/application/src/main/resources/networks/preprod/conway-genesis.json b/application/src/main/resources/networks/preprod/conway-genesis.json index b5e9b7ea..e690f455 100644 --- a/application/src/main/resources/networks/preprod/conway-genesis.json +++ b/application/src/main/resources/networks/preprod/conway-genesis.json @@ -1,3 +1,38 @@ { - "genDelegs": {} + "poolVotingThresholds": { + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "hardForkInitiation": 0.51, + "motionNoConfidence": 0.51, + "ppSecurityGroup": 0.51 + }, + "dRepVotingThresholds": { + "motionNoConfidence": 0.51, + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "updateToConstitution": 0.51, + "hardForkInitiation": 0.51, + "ppNetworkGroup": 0.51, + "ppEconomicGroup": 0.51, + "ppTechnicalGroup": 0.51, + "ppGovGroup": 0.51, + "treasuryWithdrawal": 0.51 + }, + "committeeMinSize": 0, + "committeeMaxTermLength": 200, + "govActionLifetime": 10, + "govActionDeposit": 1000000000, + "dRepDeposit": 2000000, + "dRepActivity": 20, + "constitution": { + "anchor": { + "url": "", + "dataHash": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + "committee": { + "members": { + }, + "quorum": 0 + } } \ No newline at end of file diff --git a/application/src/main/resources/networks/preview/conway-genesis.json b/application/src/main/resources/networks/preview/conway-genesis.json index 4525ef4a..e690f455 100644 --- a/application/src/main/resources/networks/preview/conway-genesis.json +++ b/application/src/main/resources/networks/preview/conway-genesis.json @@ -1,3 +1,38 @@ { - "genDelegs": {} -} + "poolVotingThresholds": { + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "hardForkInitiation": 0.51, + "motionNoConfidence": 0.51, + "ppSecurityGroup": 0.51 + }, + "dRepVotingThresholds": { + "motionNoConfidence": 0.51, + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "updateToConstitution": 0.51, + "hardForkInitiation": 0.51, + "ppNetworkGroup": 0.51, + "ppEconomicGroup": 0.51, + "ppTechnicalGroup": 0.51, + "ppGovGroup": 0.51, + "treasuryWithdrawal": 0.51 + }, + "committeeMinSize": 0, + "committeeMaxTermLength": 200, + "govActionLifetime": 10, + "govActionDeposit": 1000000000, + "dRepDeposit": 2000000, + "dRepActivity": 20, + "constitution": { + "anchor": { + "url": "", + "dataHash": "0000000000000000000000000000000000000000000000000000000000000000" + } + }, + "committee": { + "members": { + }, + "quorum": 0 + } +} \ No newline at end of file diff --git a/application/src/main/resources/networks/sanchonet/conway-genesis.json b/application/src/main/resources/networks/sanchonet/conway-genesis.json index 078d33b1..e690f455 100644 --- a/application/src/main/resources/networks/sanchonet/conway-genesis.json +++ b/application/src/main/resources/networks/sanchonet/conway-genesis.json @@ -1,28 +1,29 @@ { "poolVotingThresholds": { - "pvtCommitteeNormal": 0.51, - "pvtCommitteeNoConfidence": 0.51, - "pvtHardForkInitiation": 0.51, - "pvtMotionNoConfidence": 0.51 + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "hardForkInitiation": 0.51, + "motionNoConfidence": 0.51, + "ppSecurityGroup": 0.51 }, "dRepVotingThresholds": { - "dvtMotionNoConfidence": 0.51, - "dvtCommitteeNormal": 0.51, - "dvtCommitteeNoConfidence": 0.51, - "dvtUpdateToConstitution": 0.51, - "dvtHardForkInitiation": 0.51, - "dvtPPNetworkGroup": 0.51, - "dvtPPEconomicGroup": 0.51, - "dvtPPTechnicalGroup": 0.51, - "dvtPPGovGroup": 0.51, - "dvtTreasuryWithdrawal": 0.51 + "motionNoConfidence": 0.51, + "committeeNormal": 0.51, + "committeeNoConfidence": 0.51, + "updateToConstitution": 0.51, + "hardForkInitiation": 0.51, + "ppNetworkGroup": 0.51, + "ppEconomicGroup": 0.51, + "ppTechnicalGroup": 0.51, + "ppGovGroup": 0.51, + "treasuryWithdrawal": 0.51 }, "committeeMinSize": 0, - "committeeMaxTermLength": 60, - "govActionLifetime": 14, - "govActionDeposit": 0, - "dRepDeposit": 0, - "dRepActivity": 0, + "committeeMaxTermLength": 200, + "govActionLifetime": 10, + "govActionDeposit": 1000000000, + "dRepDeposit": 2000000, + "dRepActivity": 20, "constitution": { "anchor": { "url": "", @@ -34,4 +35,4 @@ }, "quorum": 0 } -} +} \ No newline at end of file diff --git a/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/EpochParam.java b/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/EpochParam.java index 839df6ca..5a01d673 100644 --- a/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/EpochParam.java +++ b/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/EpochParam.java @@ -5,6 +5,7 @@ import org.cardanofoundation.ledgersync.consumercommon.validation.Word31Type; import org.cardanofoundation.ledgersync.consumercommon.validation.Word64Type; +import java.math.BigDecimal; import java.math.BigInteger; import java.util.Objects; @@ -176,6 +177,87 @@ public class EpochParam extends BaseEntity { @EqualsAndHashCode.Exclude private Block block; + // Conway era params + @Column(name = "pvt_motion_no_confidence") + private Double pvtMotionNoConfidence; + + @Column(name = "pvt_commit_normal") + private Double pvtCommitteeNormal; + + @Column(name = "pvt_committee_no_confidence") + private Double pvtCommitteeNoConfidence; + + @Column(name = "pvt_hard_fork_initiation") + private Double pvtHardForkInitiation; + + @Column(name = "pvt_p_p_security_group") + private Double pvtPPSecurityGroup; + + @Column(name = "dvt_motion_no_confidence") + private Double dvtMotionNoConfidence; + + @Column(name = "dvt_commitee_normal") + private Double dvtCommitteeNormal; + + @Column(name = "dvt_committee_no_confidence") + private Double dvtCommitteeNoConfidence; + + @Column(name = "dvt_update_to_constitution") + private Double dvtUpdateToConstitution; + + @Column(name = "dvt_hard_fork_initiation") + private Double dvtHardForkInitiation; + + @Column(name = "dvt_p_p_network_group") + private Double dvtPPNetworkGroup; + + @Column(name = "dvt_p_p_economic_group") + private Double dvtPPEconomicGroup; + + @Column(name = "pvt_p_p_technical_group") + private Double dvtPPTechnicalGroup; + + @Column(name = "pvt_p_p_gov_group") + private Double dvtPPGovGroup; + + @Column(name = "pvt_treasury_withdrawal") + private Double dvtTreasuryWithdrawal; + + @Column(name = "committee_min_size") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger committeeMinSize; + + @Column(name = "committee_max_term_length") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger committeeMaxTermLength; + + @Column(name = "gov_action_lifetime") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger govActionLifetime; + + @Column(name = "gov_action_deposit") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger govActionDeposit; + + @Column(name = "drep_deposit") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger drepDeposit; + + @Column(name = "drep_activity") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger drepActivity; + + @Column(name = "min_fee_ref_script_cost_per_byte") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger minFeeRefScriptCostPerByte; + @Override public boolean equals(Object o) { if (this == o) { @@ -200,6 +282,13 @@ public int hashCode() { treasuryGrowthRate, decentralisation, extraEntropy, protocolMajor, protocolMinor, minUtxoValue, minPoolCost, nonce, coinsPerUtxoSize, costModel, priceMem, priceStep, maxTxExMem, maxTxExSteps, maxBlockExMem, maxBlockExSteps, maxValSize, collateralPercent, - maxCollateralInputs, block); + maxCollateralInputs, block, + pvtMotionNoConfidence, pvtCommitteeNormal, pvtCommitteeNoConfidence, + pvtHardForkInitiation, pvtPPSecurityGroup, dvtMotionNoConfidence, + dvtCommitteeNormal, dvtCommitteeNoConfidence, dvtUpdateToConstitution, + dvtHardForkInitiation, dvtPPNetworkGroup, dvtPPEconomicGroup, + dvtPPTechnicalGroup, dvtPPGovGroup, dvtTreasuryWithdrawal, + committeeMinSize, committeeMaxTermLength, govActionLifetime, + govActionDeposit, drepDeposit, drepActivity, minFeeRefScriptCostPerByte); } } diff --git a/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/ParamProposal.java b/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/ParamProposal.java index 1398a02a..5cca422f 100644 --- a/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/ParamProposal.java +++ b/components/consumer-common/src/main/java/org/cardanofoundation/ledgersync/consumercommon/entity/ParamProposal.java @@ -1,5 +1,6 @@ package org.cardanofoundation.ledgersync.consumercommon.entity; +import java.math.BigDecimal; import java.math.BigInteger; import java.util.Objects; @@ -189,6 +190,87 @@ public class ParamProposal extends BaseEntity { @Digits(integer = 20, fraction = 0) private BigInteger coinsPerUtxoSize; + // conway new params + @Column(name = "pvt_motion_no_confidence") + private Double pvtMotionNoConfidence; + + @Column(name = "pvt_commit_normal") + private Double pvtCommitteeNormal; + + @Column(name = "pvt_committee_no_confidence") + private Double pvtCommitteeNoConfidence; + + @Column(name = "pvt_hard_fork_initiation") + private Double pvtHardForkInitiation; + + @Column(name = "pvt_p_p_security_group") + private Double pvtPPSecurityGroup; + + @Column(name = "dvt_motion_no_confidence") + private Double dvtMotionNoConfidence; + + @Column(name = "dvt_commitee_normal") + private Double dvtCommitteeNormal; + + @Column(name = "dvt_committee_no_confidence") + private Double dvtCommitteeNoConfidence; + + @Column(name = "dvt_update_to_constitution") + private Double dvtUpdateToConstitution; + + @Column(name = "dvt_hard_fork_initiation") + private Double dvtHardForkInitiation; + + @Column(name = "dvt_p_p_network_group") + private Double dvtPPNetworkGroup; + + @Column(name = "dvt_p_p_economic_group") + private Double dvtPPEconomicGroup; + + @Column(name = "pvt_p_p_technical_group") + private Double dvtPPTechnicalGroup; + + @Column(name = "pvt_p_p_gov_group") + private Double dvtPPGovGroup; + + @Column(name = "pvt_treasury_withdrawal") + private Double dvtTreasuryWithdrawal; + + @Column(name = "committee_min_size") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger committeeMinSize; + + @Column(name = "committee_max_term_length") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger committeeMaxTermLength; + + @Column(name = "gov_action_lifetime") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger govActionLifetime; + + @Column(name = "gov_action_deposit") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger govActionDeposit; + + @Column(name = "drep_deposit") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger drepDeposit; + + @Column(name = "drep_activity") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger drepActivity; + + @Column(name = "min_fee_ref_script_cost_per_byte") + @Word64Type + @Digits(integer = 20, fraction = 0) + private BigInteger minFeeRefScriptCostPerByte; + @Override public boolean equals(Object o) { if (this == o) { @@ -217,8 +299,19 @@ public int hashCode() { getHashCode(costModel) + getHashCode(priceMem) + getHashCode(priceStep) + getHashCode(maxTxExMem) + getHashCode(maxTxExSteps) + getHashCode(maxBlockExMem) + getHashCode(maxBlockExSteps) + getHashCode(maxValSize) + getHashCode(collateralPercent) + - getHashCode(maxCollateralInputs) + getHashCode(registeredTx) + - getHashCode(coinsPerUtxoSize); + getHashCode(maxCollateralInputs) + getHashCode(registeredTx) + getHashCode(coinsPerUtxoSize) + + getHashCode(pvtMotionNoConfidence) + getHashCode(pvtCommitteeNormal) + + getHashCode(pvtCommitteeNoConfidence) + getHashCode(pvtHardForkInitiation) + + getHashCode(pvtPPSecurityGroup) + getHashCode(dvtMotionNoConfidence) + + getHashCode(dvtCommitteeNormal) + getHashCode(dvtCommitteeNoConfidence) + + getHashCode(dvtUpdateToConstitution) + getHashCode(dvtHardForkInitiation) + + getHashCode(dvtPPNetworkGroup) + getHashCode(dvtPPEconomicGroup) + + getHashCode(dvtPPTechnicalGroup) + getHashCode(dvtPPGovGroup) + + getHashCode(dvtTreasuryWithdrawal) + + getHashCode(committeeMinSize) + getHashCode(committeeMaxTermLength) + + getHashCode(govActionLifetime) + getHashCode(govActionDeposit) + + getHashCode(drepDeposit) + getHashCode(drepActivity) + + getHashCode(minFeeRefScriptCostPerByte); } private int getHashCode(Object o) { From 4bc0dfbbdb547eb84765bbc715bb193a1e1c7141 Mon Sep 17 00:00:00 2001 From: Sotatek-HuyLe3a Date: Tue, 19 Mar 2024 11:25:42 +0700 Subject: [PATCH 3/4] chore: #147 update unit tests --- .../impl/EpochParamServiceImplTest.java | 82 +++++++++++++++ .../service/impl/GenesisServiceTest.java | 99 +++++++++++++++++-- 2 files changed, 175 insertions(+), 6 deletions(-) diff --git a/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImplTest.java b/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImplTest.java index daef2449..f59b9f15 100644 --- a/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImplTest.java +++ b/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/EpochParamServiceImplTest.java @@ -220,4 +220,86 @@ void setDefShelleyEpochParamEraAlonzo() { .updateByParamProposal(any(), any()); Mockito.verify(costModelService, Mockito.times(1)).getGenesisCostModel(); } + + @Test + void setDefShelleyEpochParamEraConway() { + BlockRepository blockRepository = Mockito.mock(BlockRepository.class); + ParamProposalRepository paramProposalRepository = Mockito.mock(ParamProposalRepository.class); + EpochParamRepository epochParamRepository = Mockito.mock(EpochParamRepository.class); + EpochRepository epochRepository = Mockito.mock(EpochRepository.class); + CostModelService costModelService = Mockito.mock(CostModelService.class); + GenesisDataService genesisDataService = Mockito.mock(GenesisDataService.class); + EpochParamMapper epochParamMapper = Mockito.mock(EpochParamMapper.class); + + EpochParam defShelleyEpochParam = Mockito.mock(EpochParam.class); + EpochParam defAlonzoEpochParam = Mockito.mock(EpochParam.class); + EpochParam defBabbageEpochParam = Mockito.mock(EpochParam.class); + EpochParam defConwayEpochParam = Mockito.mock(EpochParam.class); + + Epoch epoch = Mockito.mock(Epoch.class); + Epoch epoch2 = Mockito.mock(Epoch.class); + EpochParam mockEpochParam = Mockito.mock(EpochParam.class); + + Mockito.when(mockEpochParam.getEpochNo()).thenReturn(4); + Mockito.when(epochParamRepository.findLastEpochParam()).thenReturn(Optional.of(mockEpochParam)); + + Optional prevEpochParam = Optional.of(defBabbageEpochParam); + Mockito.when(epochParamRepository.findEpochParamByEpochNo(4)) + .thenReturn(prevEpochParam); + Mockito.when(epoch.getNo()).thenReturn(5); + Mockito.when(epoch.getMaxSlot()).thenReturn(ConsumerConstant.FIVE_DAYS); + Mockito.when(epoch.getEra()).thenReturn(EraType.valueOf(EraType.CONWAY.getValue())); + Mockito.when(epoch2.getNo()).thenReturn(4); + Mockito.when(epoch2.getMaxSlot()).thenReturn(ConsumerConstant.FIVE_DAYS); + Mockito.when(epoch2.getEra()).thenReturn(EraType.valueOf(EraType.BABBAGE.getValue())); + Mockito.when(epochRepository.findEpochNoByMaxSlotAndEpochNoMoreThanLastEpochParam( + Mockito.eq(ConsumerConstant.FIVE_DAYS), Mockito.anyInt())) + .thenReturn(List.of(5)); + Mockito.when(genesisDataService.getShelleyEpochLength()).thenReturn(ConsumerConstant.FIVE_DAYS); + + Optional optionalEpoch = Optional.of(epoch); + Optional optionalEpoch2 = Optional.of(epoch2); + + Mockito.when(genesisDataService.getUpdateQuorum()).thenReturn(4); + Mockito.when(genesisDataService.getDelegationKeyHashes()).thenReturn(Set.of( + "637f2e950b0fd8f8e3e811c5fbeb19e411e7a2bf37272b84b29c1a0b", + "8a4b77c4f534f8b8cc6f269e5ebb7ba77fa63a476e50e05e66d7051c", + "b00470cd193d67aac47c373602fccd4195aad3002c169b5570de1126", + "b260ffdb6eba541fcf18601923457307647dce807851b9d19da133ab" + )); + + ParamProposal paramProposal1 = Mockito.mock(ParamProposal.class); + ParamProposal paramProposal2 = Mockito.mock(ParamProposal.class); + ParamProposal paramProposal3 = Mockito.mock(ParamProposal.class); + ParamProposal paramProposal4 = Mockito.mock(ParamProposal.class); + + Mockito.when(paramProposal1.getKey()).thenReturn("637f2e950b0fd8f8e3e811c5fbeb19e411e7a2bf37272b84b29c1a0b"); + Mockito.when(paramProposal2.getKey()).thenReturn("8a4b77c4f534f8b8cc6f269e5ebb7ba77fa63a476e50e05e66d7051c"); + Mockito.when(paramProposal3.getKey()).thenReturn("b00470cd193d67aac47c373602fccd4195aad3002c169b5570de1126"); + Mockito.when(paramProposal4.getKey()).thenReturn("b260ffdb6eba541fcf18601923457307647dce807851b9d19da133ab"); + + List prevParamProposals = List.of(paramProposal1, paramProposal2, paramProposal3, paramProposal4); + Mockito.when(paramProposalRepository.findParamProposalsByEpochNo(4)) + .thenReturn(prevParamProposals); + Block cachedBlock = Mockito.mock(Block.class); + Optional optionalBlock = Optional.of(cachedBlock); + Mockito.when(epochRepository.findEpochByNo(5)).thenReturn(optionalEpoch); + Mockito.when(epochRepository.findEpochByNo(4)).thenReturn(optionalEpoch2); + Mockito.when(blockRepository.findFirstByEpochNo(5)).thenReturn(optionalBlock); + + EpochParamServiceImpl epochParamServiceImpl = new EpochParamServiceImpl(blockRepository, + paramProposalRepository, epochParamRepository, epochRepository, + costModelService, genesisDataService, epochParamMapper); + epochParamServiceImpl.setDefShelleyEpochParam(defShelleyEpochParam); + epochParamServiceImpl.setDefAlonzoEpochParam(defAlonzoEpochParam); + epochParamServiceImpl.setDefBabbageEpochParam(defBabbageEpochParam); + epochParamServiceImpl.setDefConwayEpochParam(defConwayEpochParam); + epochParamServiceImpl.handleEpochParams(); + + Mockito.verify(epochParamRepository, Mockito.times(1)).save(any()); + Mockito.verify(epochParamMapper, Mockito.times(2)) + .updateByEpochParam(any(), any()); + Mockito.verify(epochParamMapper, Mockito.times(1)) + .updateByParamProposal(any(), any()); + } } \ No newline at end of file diff --git a/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/GenesisServiceTest.java b/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/GenesisServiceTest.java index 9ff8b991..33fb0d4c 100644 --- a/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/GenesisServiceTest.java +++ b/application/src/test/java/org/cardanofoundation/ledgersync/service/impl/GenesisServiceTest.java @@ -79,13 +79,14 @@ void testGenesisMainnetInternetFetching() { "https://book.world.dev.cardano.org/environments/mainnet/shelley-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", "https://book.world.dev.cardano.org/environments/mainnet/alonzo-genesis.json"); - ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", - "https://book.world.dev.cardano.org/environments/mainnet/alonzo-genesis.json"); + ReflectionTestUtils.setField(genesisDataService, "genesisConway", + "https://book.world.dev.cardano.org/environments/mainnet/conway-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisFetching", genesisWebClientFetching); genesisDataService.fetchShelleyGenesis(data); genesisDataService.fetchAlonzoGenesis(data); genesisDataService.setupBabbageGenesis(data); + genesisDataService.fetchConwayGenesis(data); genesisDataService.fetchTransactionAndTransactionOutput(data); genesisDataService.fetchBlockAndSlotLeader(data); @@ -97,6 +98,7 @@ void testGenesisMainnetInternetFetching() { Assertions.assertNotNull(data.getCostModel()); Assertions.assertNotNull(data.getShelley()); Assertions.assertNotNull(data.getAlonzo()); + Assertions.assertNotNull(data.getConway()); //check block Assertions.assertEquals("5f20df933584822601f9e3f8c024eb5eb252fe8cefb24d1317dc3d432e940ebb", @@ -206,6 +208,33 @@ void testGenesisMainnetInternetFetching() { .build(); Assertions.assertEquals(babbageGenesis.hashCode(), data.getBabbage().hashCode()); + + // conway protocol + EpochParam conwayGenesis = EpochParam.builder() + .pvtMotionNoConfidence(0.51) + .pvtCommitteeNormal(0.51) + .pvtCommitteeNoConfidence(0.51) + .pvtHardForkInitiation(0.51) + .pvtPPSecurityGroup(0.51) + .dvtMotionNoConfidence(0.51) + .dvtCommitteeNormal(0.51) + .dvtCommitteeNoConfidence(0.51) + .dvtUpdateToConstitution(0.51) + .dvtHardForkInitiation(0.51) + .dvtPPNetworkGroup(0.51) + .dvtPPEconomicGroup(0.51) + .dvtPPTechnicalGroup(0.51) + .dvtPPGovGroup(0.51) + .dvtTreasuryWithdrawal(0.51) + .committeeMinSize(BigInteger.valueOf(0)) + .committeeMaxTermLength(BigInteger.valueOf(200)) + .govActionLifetime(BigInteger.valueOf(10)) + .govActionDeposit(BigInteger.valueOf(1000000000)) + .drepDeposit(BigInteger.valueOf(2000000)) + .drepActivity(BigInteger.valueOf(20)) + .build(); + + Assertions.assertEquals(conwayGenesis.hashCode(), data.getConway().hashCode()); } @Test @@ -224,15 +253,16 @@ void testGenesisPreprodInternetFetching() { "https://book.world.dev.cardano.org/environments/preprod/shelley-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", "https://book.world.dev.cardano.org/environments/preprod/alonzo-genesis.json"); - + ReflectionTestUtils.setField(genesisDataService, "genesisConway", + "https://book.world.dev.cardano.org/environments/mainnet/conway-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisFetching", genesisWebClientFetching); genesisDataService.fetchTransactionAndTransactionOutput(data); genesisDataService.fetchShelleyGenesis(data); genesisDataService.fetchAlonzoGenesis(data); genesisDataService.setupBabbageGenesis(data); + genesisDataService.fetchConwayGenesis(data); genesisDataService.fetchBlockAndSlotLeader(data); - // check block Assertions.assertEquals( "d4b8de7a11d929a323373cbab6c1a9bdc931beffff11db111cf9d57356ee1937", @@ -333,6 +363,33 @@ void testGenesisPreprodInternetFetching() { .build(); Assertions.assertEquals(babbageGenesis.hashCode(), data.getBabbage().hashCode()); + + // conway protocol + EpochParam conwayGenesis = EpochParam.builder() + .pvtMotionNoConfidence(0.51) + .pvtCommitteeNormal(0.51) + .pvtCommitteeNoConfidence(0.51) + .pvtHardForkInitiation(0.51) + .pvtPPSecurityGroup(0.51) + .dvtMotionNoConfidence(0.51) + .dvtCommitteeNormal(0.51) + .dvtCommitteeNoConfidence(0.51) + .dvtUpdateToConstitution(0.51) + .dvtHardForkInitiation(0.51) + .dvtPPNetworkGroup(0.51) + .dvtPPEconomicGroup(0.51) + .dvtPPTechnicalGroup(0.51) + .dvtPPGovGroup(0.51) + .dvtTreasuryWithdrawal(0.51) + .committeeMinSize(BigInteger.valueOf(0)) + .committeeMaxTermLength(BigInteger.valueOf(200)) + .govActionLifetime(BigInteger.valueOf(10)) + .govActionDeposit(BigInteger.valueOf(1000000000)) + .drepDeposit(BigInteger.valueOf(2000000)) + .drepActivity(BigInteger.valueOf(20)) + .build(); + + Assertions.assertEquals(conwayGenesis.hashCode(), data.getConway().hashCode()); } @Test @@ -350,13 +407,14 @@ void testGenesisMainnetLocal() { "classpath:networks/mainnet/shelley-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", "classpath:networks/mainnet/alonzo-genesis.json"); - ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", - "classpath:networks/mainnet/alonzo-genesis.json"); + ReflectionTestUtils.setField(genesisDataService, "genesisConway", + "classpath:networks/mainnet/conway-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisFetching", genesisLocalFetching); genesisDataService.fetchShelleyGenesis(data); genesisDataService.fetchAlonzoGenesis(data); genesisDataService.setupBabbageGenesis(data); + genesisDataService.fetchConwayGenesis(data); genesisDataService.fetchTransactionAndTransactionOutput(data); genesisDataService.fetchBlockAndSlotLeader(data); @@ -477,6 +535,33 @@ void testGenesisMainnetLocal() { .build(); Assertions.assertEquals(babbageGenesis.hashCode(), data.getBabbage().hashCode()); + + // conway protocol + EpochParam conwayGenesis = EpochParam.builder() + .pvtMotionNoConfidence(0.51) + .pvtCommitteeNormal(0.51) + .pvtCommitteeNoConfidence(0.51) + .pvtHardForkInitiation(0.51) + .pvtPPSecurityGroup(0.51) + .dvtMotionNoConfidence(0.51) + .dvtCommitteeNormal(0.51) + .dvtCommitteeNoConfidence(0.51) + .dvtUpdateToConstitution(0.51) + .dvtHardForkInitiation(0.51) + .dvtPPNetworkGroup(0.51) + .dvtPPEconomicGroup(0.51) + .dvtPPTechnicalGroup(0.51) + .dvtPPGovGroup(0.51) + .dvtTreasuryWithdrawal(0.51) + .committeeMinSize(BigInteger.valueOf(0)) + .committeeMaxTermLength(BigInteger.valueOf(200)) + .govActionLifetime(BigInteger.valueOf(10)) + .govActionDeposit(BigInteger.valueOf(1000000000)) + .drepDeposit(BigInteger.valueOf(2000000)) + .drepActivity(BigInteger.valueOf(20)) + .build(); + + Assertions.assertEquals(conwayGenesis.hashCode(), data.getConway().hashCode()); } @Test @@ -495,6 +580,8 @@ void testGenesisPreProdLocal() { "classpath:networks/preprod/shelley-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisAlonzo", "classpath:networks/preprod/alonzo-genesis.json"); + ReflectionTestUtils.setField(genesisDataService, "genesisConway", + "classpath:networks/preprod/conway-genesis.json"); ReflectionTestUtils.setField(genesisDataService, "genesisFetching", genesisLocalFetching); genesisDataService.fetchTransactionAndTransactionOutput(data); From 3f2333d18db4837cef8a6006d3b20d6eac4caf91 Mon Sep 17 00:00:00 2001 From: Sotatek-HuyLe3a Date: Wed, 20 Mar 2024 09:59:55 +0700 Subject: [PATCH 4/4] fix: #147 Fix incorrect data mapping --- .../impl/ParamProposalServiceImpl.java | 12 ++-- .../impl/genesis/GenesisDataServiceImpl.java | 60 +++++++++---------- 2 files changed, 36 insertions(+), 36 deletions(-) diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java index 0476520a..2035818c 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/ParamProposalServiceImpl.java @@ -138,12 +138,12 @@ private List handleParamProposal(AggregatedTx aggregatedTx, Tx tx if (drepVotingThresholds != null) { dvtMotionNoConfidence = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtCommitteeNormal = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtCommitteeNoConfidence = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtUpdateToConstitution = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtHardForkInitiation = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtPPNetworkGroup = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); - dvtPPEconomicGroup = toDouble(drepVotingThresholds.getDvtMotionNoConfidence()); + dvtCommitteeNormal = toDouble(drepVotingThresholds.getDvtCommitteeNormal()); + dvtCommitteeNoConfidence = toDouble(drepVotingThresholds.getDvtCommitteeNoConfidence()); + dvtUpdateToConstitution = toDouble(drepVotingThresholds.getDvtUpdateToConstitution()); + dvtHardForkInitiation = toDouble(drepVotingThresholds.getDvtHardForkInitiation()); + dvtPPNetworkGroup = toDouble(drepVotingThresholds.getDvtPPNetworkGroup()); + dvtPPEconomicGroup = toDouble(drepVotingThresholds.getDvtPPEconomicGroup()); dvtPPTechnicalGroup = toDouble(drepVotingThresholds.getDvtPPTechnicalGroup()); dvtPPGovGroup = toDouble(drepVotingThresholds.getDvtPPGovGroup()); dvtTreasuryWithdrawal = toDouble(drepVotingThresholds.getDvtTreasuryWithdrawal()); diff --git a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java index a9736b1e..812043dc 100644 --- a/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java +++ b/application/src/main/java/org/cardanofoundation/ledgersync/service/impl/genesis/GenesisDataServiceImpl.java @@ -89,22 +89,22 @@ public class GenesisDataServiceImpl implements GenesisDataService { public static final String DELEGATION_KEYS = "genDelegs"; private final static String POOL_VOTING_THRESHOLDS = "poolVotingThresholds"; - private final static String COMMITTEE_NORMAL = "committeeNormal"; - private final static String COMMITTEE_NO_CONFIDENCE = "committeeNoConfidence"; - private final static String HARD_FORK_INITIATION = "hardForkInitiation"; - private final static String MOTION_NO_CONFIDENCE = "motionNoConfidence"; - private final static String PP_SECURITY_GROUP = "ppSecurityGroup"; + private final static String PVT_COMMITTEE_NORMAL = "committeeNormal"; + private final static String PVT_COMMITTEE_NO_CONFIDENCE = "committeeNoConfidence"; + private final static String PVT_HARD_FORK_INITIATION = "hardForkInitiation"; + private final static String PVT_MOTION_NO_CONFIDENCE = "motionNoConfidence"; + private final static String PVT_PP_SECURITY_GROUP = "ppSecurityGroup"; private final static String D_REP_VOTING_THRESHOLDS = "dRepVotingThresholds"; - private final static String MOTION_NO_CONFIDENCE1 = "motionNoConfidence"; - private final static String COMMITTEE_NORMAL1 = "committeeNormal"; - private final static String COMMITTEE_NO_CONFIDENCE1 = "committeeNoConfidence"; - private final static String UPDATE_TO_CONSTITUTION = "updateToConstitution"; - private final static String HARD_FORK_INITIATION1 = "hardForkInitiation"; - private final static String PP_NETWORK_GROUP = "ppNetworkGroup"; - private final static String PP_ECONOMIC_GROUP = "ppEconomicGroup"; - private final static String PP_TECHNICAL_GROUP = "ppTechnicalGroup"; - private final static String PP_GOV_GROUP = "ppGovGroup"; - private final static String TREASURY_WITHDRAWAL = "treasuryWithdrawal"; + private final static String DVT_MOTION_NO_CONFIDENCE = "motionNoConfidence"; + private final static String DVT_COMMITTEE_NORMAL = "committeeNormal"; + private final static String DVT_COMMITTEE_NO_CONFIDENCE = "committeeNoConfidence"; + private final static String DVT_UPDATE_TO_CONSTITUTION = "updateToConstitution"; + private final static String DVT_HARD_FORK_INITIATION = "hardForkInitiation"; + private final static String DVT_PP_NETWORK_GROUP = "ppNetworkGroup"; + private final static String DVT_PP_ECONOMIC_GROUP = "ppEconomicGroup"; + private final static String DVT_PP_TECHNICAL_GROUP = "ppTechnicalGroup"; + private final static String DVT_PP_GOV_GROUP = "ppGovGroup"; + private final static String DVT_TREASURY_WITHDRAWAL = "treasuryWithdrawal"; private final static String COMMITTEE_MIN_SIZE = "committeeMinSize"; private final static String COMMITTEE_MAX_TERM_LENGTH = "committeeMaxTermLength"; @@ -379,21 +379,21 @@ public void fetchConwayGenesis(GenesisData genesisData) { final var dRepVotingThresholds = (Map) genesisConwayJsonMap.get(D_REP_VOTING_THRESHOLDS); EpochParam genesisShelleyProtocols = EpochParam.builder() - .pvtCommitteeNormal(convertObjectToBigDecimal(poolVotingThresholds.get(COMMITTEE_NORMAL)).doubleValue()) - .pvtCommitteeNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(COMMITTEE_NO_CONFIDENCE)).doubleValue()) - .pvtHardForkInitiation(convertObjectToBigDecimal(poolVotingThresholds.get(HARD_FORK_INITIATION)).doubleValue()) - .pvtMotionNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .pvtPPSecurityGroup(convertObjectToBigDecimal(poolVotingThresholds.get(PP_SECURITY_GROUP)).doubleValue()) - .dvtMotionNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE1)).doubleValue()) - .dvtCommitteeNormal(convertObjectToBigDecimal(dRepVotingThresholds.get(COMMITTEE_NORMAL1)).doubleValue()) - .dvtCommitteeNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(COMMITTEE_NO_CONFIDENCE1)).doubleValue()) - .dvtUpdateToConstitution(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtHardForkInitiation(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtPPNetworkGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtPPEconomicGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtPPTechnicalGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtPPGovGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) - .dvtTreasuryWithdrawal(convertObjectToBigDecimal(dRepVotingThresholds.get(MOTION_NO_CONFIDENCE)).doubleValue()) + .pvtCommitteeNormal(convertObjectToBigDecimal(poolVotingThresholds.get(PVT_COMMITTEE_NORMAL)).doubleValue()) + .pvtCommitteeNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(PVT_COMMITTEE_NO_CONFIDENCE)).doubleValue()) + .pvtHardForkInitiation(convertObjectToBigDecimal(poolVotingThresholds.get(PVT_HARD_FORK_INITIATION)).doubleValue()) + .pvtMotionNoConfidence(convertObjectToBigDecimal(poolVotingThresholds.get(PVT_MOTION_NO_CONFIDENCE)).doubleValue()) + .pvtPPSecurityGroup(convertObjectToBigDecimal(poolVotingThresholds.get(PVT_PP_SECURITY_GROUP)).doubleValue()) + .dvtMotionNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_MOTION_NO_CONFIDENCE)).doubleValue()) + .dvtCommitteeNormal(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_COMMITTEE_NORMAL)).doubleValue()) + .dvtCommitteeNoConfidence(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_COMMITTEE_NO_CONFIDENCE)).doubleValue()) + .dvtUpdateToConstitution(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_UPDATE_TO_CONSTITUTION)).doubleValue()) + .dvtHardForkInitiation(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_HARD_FORK_INITIATION)).doubleValue()) + .dvtPPNetworkGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_PP_NETWORK_GROUP)).doubleValue()) + .dvtPPEconomicGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_PP_ECONOMIC_GROUP)).doubleValue()) + .dvtPPTechnicalGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_PP_TECHNICAL_GROUP)).doubleValue()) + .dvtPPGovGroup(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_PP_GOV_GROUP)).doubleValue()) + .dvtTreasuryWithdrawal(convertObjectToBigDecimal(dRepVotingThresholds.get(DVT_TREASURY_WITHDRAWAL)).doubleValue()) .committeeMinSize(convertObjecToBigInteger(genesisConwayJsonMap.get(COMMITTEE_MIN_SIZE))) .committeeMaxTermLength(convertObjecToBigInteger(genesisConwayJsonMap.get(COMMITTEE_MAX_TERM_LENGTH))) .govActionLifetime(convertObjecToBigInteger(genesisConwayJsonMap.get(GOV_ACTION_LIFETIME)))