Evidence

own codetransaction-encoding

Stake key registration and deregistration are encoded as certificate types 0 and 1. Dijkstra rejects deposit-less stake (de)registration certificates (types 0 and 1); on the devnet a Conway transaction carrying one is refused after the fork (cross-era-submission).

• app/frontend/types.ts:50STAKING_KEY_REGISTRATION = 0,
• app/frontend/wallet/shelley/shelley-transaction.ts:178return [TxCertificateKey.STAKING_KEY_REGISTRATION, stakeCredential]
• app/frontend/wallet/shelley/shelley-transaction.ts:189return [TxCertificateKey.STAKING_KEY_DEREGISTRATION, stakeCredential]

cardano-db-syncblock-encodingera-identitytransaction-encoding

Verifies ad payments by querying db-sync transaction outputs. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• server/poolAdsModule.js:93JOIN tx_out ON tx_out.tx_id = tx.id

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The explorer API is built on db-sync tables: transaction outputs, epoch parameters and pool registrations. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• backend/lib/models/addresses.ts:438FROM ma_tx_out
• backend/lib/models/accounts.ts:280FROM epoch_param AS ep
• backend/lib/helpers/gov-actions.ts:223JOIN pool_update AS pu ON pu.id = aep.update_id

gouroborosblock-encodingera-identity

Decodes blocks and mempool transactions with pre-target ledger types.

• input/utxorpc/mapper.go:95block, err := ledger.NewBlockFromCbor(wb.Type, wb.RawBlock)
• input/mempool/mempool.go:412return ledger.NewTransactionFromCbor(txType, data)

kupoblock-encodingera-identitytransaction-encoding

The chain-sync input resolves transaction inputs through Kupo when configured; after the fork Kupo cannot index Dijkstra blocks and Adder emits events without resolved inputs.

• input/chainsync/chainsync.go:574"failed to resolve transaction inputs via Kupo, emitting without resolved inputs",

kupoblock-encodingera-identitytransaction-encoding

The Ogmios chain context looks UTxOs up through Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• backend/ogmios/client.go:339matches, err := c.client.Matches(

ogmiostransaction-encodingera-identity

Submits transactions through Ogmios, whose v7 release encodes an earlier Dijkstra transaction format.

• backend/ogmios/ogmios.go:354func (o *OgmiosChainContext) SubmitTxContext(ctx context.Context, txCbor []byte) (common.Blake2b256, error) {

ogmiosplutus-language

Evaluates script execution units through Ogmios.

• backend/ogmios/ogmios.go:373func (o *OgmiosChainContext) EvaluateTxContext(

ogmiosprotocol-parameters

Reads protocol parameters from Ogmios for transaction building.

• backend/ogmios/ogmios.go:220func (o *OgmiosChainContext) ProtocolParamsContext(ctx context.Context) (backend.ProtocolParameters, error) {

blockfrostprotocol-parameters

The Blockfrost backend builds transactions from /epochs/latest/parameters, which serves no Dijkstra parameters.

• backend/blockfrost/blockfrost.go:136data, err := b.requestContext(ctx, "GET", "/epochs/latest/parameters", nil, "")

koiosprotocol-parameters

The new Koios backend builds from /epoch_params, reaching the provider's unresolved Dijkstra parameter handling.

• backend/koios/koios.go:172path := "/epoch_params?_epoch_no="

cardano-apicardano-api-haskellera-identitytransaction-encoding

Node queries are fixed to the Conway era on cardano-api 10.13.1.

• src/GeniusYield/CardanoApi/Query.hs:49queryConwayEra info q = do

kupoblock-encodingera-identitytransaction-encoding

The Kupo provider answers UTxO queries. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• src/GeniusYield/Providers/Kupo.hs:349kupoQueryUtxo :: KupoApiEnv -> GYQueryUTxO

ogmiosera-identity

Era history comes from Ogmios and is parsed as exactly seven eras (Byron to Conway), so it fails once the history includes Dijkstra.

• src/GeniusYield/Providers/Ogmios.hs:907ogmiosEraSummaries :: OgmiosApiEnv -> IO Api.EraHistory
• src/GeniusYield/Providers/Common.hs:157parseEraHist mkEra [byronEra, shelleyEra, allegraEra, maryEra, alonzoEra, babbageEra, conwayEra] =

ogmiostransaction-encoding

Submits transactions through Ogmios.

• src/GeniusYield/Providers/Ogmios.hs:560ogmiosSubmitTx :: OgmiosApiEnv -> GYSubmitTx

ogmiosprotocol-parameters

Reads protocol parameters from Ogmios.

• src/GeniusYield/Providers/Ogmios.hs:809ogmiosProtocolParameters :: OgmiosApiEnv -> IO ApiProtocolParameters

blockfrostera-identity

The Blockfrost provider reads /network/eras, which throws on protocol 12, and parses it as exactly seven eras.

• src/GeniusYield/Providers/Blockfrost.hs:543eraSumms <- Blockfrost.runBlockfrost proj Blockfrost.getNetworkEras >>= handleBlockfrostError "EraHistory"

blockfrostprotocol-parameters

Builds transactions from Blockfrost's latest epoch parameters.

• src/GeniusYield/Providers/Blockfrost.hs:418Blockfrost.runBlockfrost proj Blockfrost.getLatestEpochProtocolParams

cardano-js-sdkprotocol-parameters

blaze-core re-exports @cardano-sdk/core serialization, so its parameter-update ceiling is Blaze's.

• packages/blaze-core/src/cardano.ts:1export { Cardano, Serialization } from "@cardano-sdk/core";

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider queries UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• packages/blaze-query/src/kupmios.ts:112const url = `${this.kupoUrl}/matches/${prefix ? prefix : "*"}?unspent${

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

@blaze-cardano/ogmios is an Ogmios client covering chain-sync, submission, evaluation and ledger-state queries; Kupmios takes parameters and submission from it.

• packages/blaze-ogmios/src/unwrapped.ts:136async nextBlock(): Promise<schema.NextBlockResponse["result"]> {
• packages/blaze-ogmios/src/unwrapped.ts:161>("evaluateTransaction", { transaction, additionalUtxo: additionalUtxos });
• packages/blaze-query/src/kupmios.ts:248return this.ogmios.queryLedgerStateProtocolParameters().then((result) => {

blockfrostprotocol-parameters

The Blockfrost provider builds transactions from /epochs/latest/parameters.

• packages/blaze-query/src/blockfrost.ts:75const query = "epochs/latest/parameters";

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

blaze-query's Maestro provider reads protocol parameters and submits transactions through Maestro.

• packages/blaze-query/src/maestro.ts:66const query = `/protocol-parameters`;
• packages/blaze-query/src/maestro.ts:368const query = `/txmanager`;

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The backend serves every endpoint from db-sync tables, including epoch_param for parameters and eras and pool registration tables. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• src/sql/network/network_protocols.sql:3FROM epoch_param
• src/routes/epochs/latest/parameters.ts:33rows[0].cost_models = costModelsMap(rows[0].cost_models);

blockfrostprotocol-parameters

query protocol-parameters rebuilds cardano-cli output from Blockfrost epoch parameters, which carry no Dijkstra parameters.

• src/commands/query/protocol-parameters.ts:219const epochParams = await client.epochsParameters(latestEpoch.epoch);

blockfrostera-identityprotocol-parameters

The SDK wraps /network/eras, which throws on protocol 12, and the epoch parameter endpoints, which serve no Dijkstra parameters; the fix is server-side.

• api_network.go:82func (c *apiClient) NetworkEras(ctx context.Context) (ne []NetworkEra, err error) {
• api_epochs.go:234func (c *apiClient) LatestEpochParameters(ctx context.Context) (epr EpochParameters, err error) {

blockfrostera-identityprotocol-parameters

The SDK wraps /network/eras, which throws on protocol 12, and the epoch parameter endpoints, which serve no Dijkstra parameters; the fix is server-side.

• src/endpoints/api/network/index.ts:31export async function networkEras(
• src/endpoints/api/epochs/index.ts:365export async function epochsLatestParameters(

ogmiosplutus-languagetransaction-encoding

Wraps Blockfrost's transaction evaluation, which Blockfrost answers through Ogmios.

• src/endpoints/api/utils/txs.ts:32>(`utils/txs/evaluate`, {

blockfrostera-identityprotocol-parameters

The SDK wraps /network/eras, which throws on protocol 12, and the epoch parameter endpoints, which serve no Dijkstra parameters; the fix is server-side.

• blockfrost/api/cardano/network.py:26def network_eras(self, **kwargs):
• blockfrost/api/cardano/epochs.py:27def epoch_latest_parameters(self, **kwargs):

ogmiosplutus-languagetransaction-encoding

Wraps Blockfrost's transaction evaluation, which Blockfrost answers through Ogmios.

• blockfrost/api/cardano/transactions.py:371def transaction_evaluate_cbor(self, tx_cbor: Union[bytes, str], **kwargs):

kupoblock-encodingera-identitytransaction-encoding

The Kupo UTxO supplier reads matches from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• supplier/kupo-supplier/src/main/java/com/bloxbean/cardano/client/supplier/kupo/http/MatchesApi.java:13@GET("v1/matches/{pattern}?unspent")

ogmiostransaction-encodingera-identityplutus-languageprotocol-parameters

The Ogmios backend submits and evaluates transactions and reads protocol parameters through Ogmios.

• backend-modules/ogmios/src/main/java/com/bloxbean/cardano/client/backend/ogmios/http/OgmiosTransactionService.java:55public Result<List<EvaluationResult>> evaluateTx(byte[] cborData) throws ApiException {
• backend-modules/ogmios/src/main/java/com/bloxbean/cardano/client/backend/ogmios/http/OgmiosEpochService.java:33public Result<ProtocolParams> getProtocolParameters() throws ApiException {

blockfrostprotocol-parameters

The Blockfrost backend reads protocol parameters for transaction building.

• backend-modules/blockfrost/src/main/java/com/bloxbean/cardano/client/backend/blockfrost/service/BFEpochService.java:72public Result<ProtocolParams> getProtocolParameters() throws ApiException {

koiosprotocol-parameters

The Koios backend reads epoch parameters, which Koios serves Conway-only.

• backend-modules/koios/src/main/java/com/bloxbean/cardano/client/backend/koios/KoiosEpochService.java:92rest.koios.client.backend.api.base.Result<EpochParams> epochParametersResult = epochService.getEpochParametersByEpoch(epoch);

pallasblock-encodingera-identity

Submitted transactions are era-detected with MultiEraTx::decode, which does not recognise Dijkstra's three-element form in any Pallas revision (devnet check pallas-transactions).

• src/server/submit.rs:56let metx = MultiEraTx::decode(&tx.raw)
• src/network/mempool.rs:99let tx = MultiEraTx::decode(cbor)?;

gouroborosera-identity

Bursa signing still infers the era of supplied transaction bytes through gouroboros. The current v0.216.3 probe still rejects ordinary Dijkstra transactions; this source path remains exposed.

• transaction.go:330func SignTransaction(txCbor []byte, signers []*LoadedKey) ([]byte, error) {
• transaction.go:336return nil, fmt.Errorf("failed to determine transaction era: %w", err)

ledgerjs-hw-app-cardanotransaction-encoding

The web signer hands supplied transactions to a Ledger.

• ui/web/src/hw/ledger.ts:13import Ada from "@cardano-foundation/ledgerjs-hw-app-cardano";

ogmiosprotocol-parameters

The wallet's backend returns protocol parameters in Ogmios's format, which the client parses for transaction building.

• src/dataProvider/index.ts:11import {parseOgmiosProtocolParameters} from '@/helpers'

pallasblock-encodingera-identity

Wallet sync decodes every block and header from upstream with MultiEraBlock::decode and MultiEraHeader::decode, from Pallas's default branch, which has no Dijkstra era.

• src/chain/upstream.rs:106let block = MultiEraBlock::decode(&cbor)
• src/chain/upstream.rs:141MultiEraHeader::decode(header.variant, Some(subtag), &header.cbor)
• Cargo.toml:12pallas = { git = "https://github.com/txpipe/pallas.git", features = ["unstable"] }

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

The shipped maestro helper script sends every query to the Maestro API.

• scripts/maestro:40curl -H "api-key: $project_id" -H "Accept: application/json" "$MAESTRO_URL/$query" | jq

blockfrostprotocol-parameters

The Go, JS and Python provider wrappers read /epochs/latest/parameters for transaction building.

• wrappers/js/src/providers.js:123return httpGetJson(`${this.baseUrl}/epochs/latest/parameters`, this._headers);

ogmiosplutus-languagetransaction-encoding

The remote evaluator posts transactions to a Blockfrost-compatible /utils/txs/evaluate, which Blockfrost answers through Ogmios.

• wrappers/js/src/providers.js:176// Remote evaluator via a Blockfrost-compatible `/utils/txs/evaluate` endpoint. Not exercised in CI

bloxbean-cardano-client-librarytransaction-encodingplutus-language

Decodes transactions it did not build with cardano-client-lib, whose body ends at key 22 and languages at V3. (the transaction API takes caller-supplied CBOR).

• core/src/main/java/com/bloxbean/cardano/mesmo/api/TransactionApi.java:57Transaction tx = Transaction.deserialize(HexUtil.decodeHexString(txCborHex));

blockfrostprotocol-parameters

Outside the emulator, the challenges build transactions with Lucid Evolution on a Blockfrost provider, which reads Blockfrost's epoch parameters.

• common/offchain/setup_lucid.ts:26? await Lucid(new Blockfrost(BLOCKFROST_URL, BLOCKFROST_API_KEY), 'Preview')

cardano-serialization-lib-cslplutus-language

The CIP-30 signTx handler decodes dApp-supplied transactions with CSL; a transaction carrying a PlutusV4 script or cost model fails to decode.

• webext/src/lib/CIP30/WalletApi.ts:342argsDecoded: [CSL.Transaction.from_hex(tx), partialSign],

kupoblock-encodingera-identitytransaction-encoding

The Ogmios/Kupo backend lists UTxOs from Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• webext/src/lib/CIP30/Backends/OgmiosKupo.ts:126let res = await fetch(url + "/matches/" + address.to_bech32() + "?unspent");

ogmiostransaction-encodingera-identity

The Ogmios/Kupo backend submits transactions through Ogmios.

• webext/src/lib/CIP30/Backends/OgmiosKupo.ts:61method: "submitTransaction",

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

The CIP-30 signTx handler decodes dApp-supplied transactions with CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key.

• webext/src/lib/CIP30/WalletApi.ts:342argsDecoded: [CSL.Transaction.from_hex(tx), partialSign],

blockfrostprotocol-parameters

The Blockfrost node reads latest epoch parameters for transaction building.

• blockfrost/blockfrost.go:163eparams, err := b.client.LatestEpochParameters(context.Background())

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The GraphQL API is Hasura over db-sync, including epoch_param and pool registrations. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• packages/api-cardano-db-hasura/hasura/project/migrations/default/1589369664961_init/up.sql:124epoch_param.nonce AS "nonce",
• packages/api-cardano-db-hasura/hasura/project/migrations/default/1589369664961_init/up.sql:257FROM pool_update AS pool

cardano-serialization-lib-cslplutus-language

Witness handling decodes witness sets with CSL and validates Plutus witnesses and cost models of user-supplied transactions.

• src/crypto-providers/keystoneUtils.ts:458CardanoSerializationLib.TransactionWitnessSet.from_hex(
• src/transaction/transactionValidation.ts:189const extractCostModels = (

cardano-hw-interop-libtransaction-encoding

Parses transaction files with the interop library, which rejects bodies with keys beyond 22.

• src/command-parser/parserConfig.ts:110type: (path: string) => parseTxFile(path),

ledgerjs-hw-app-cardanotransaction-encoding

Signs transactions built elsewhere (dApp requests or transaction files) on a Ledger; the Ledger transaction model ends at key 22.

• package.json:44"@cardano-foundation/ledgerjs-hw-app-cardano": "8.0.0-beta",

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

Transaction files supplied by the user are decoded with CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key (pool registration signing included).

• src/crypto-providers/keystoneUtils.ts:458CardanoSerializationLib.TransactionWitnessSet.from_hex(
• src/transaction/transactionValidation.ts:189const extractCostModels = (

gouroborosblock-encodingera-identitytransaction-encodingstake-pool-registration

The probabilistic light client decodes Cardano blocks and pool certificates with gouroboros v0.205.4, before Dijkstra block and transaction types.

• cosmos/cardano-probabilistic-light-client-core/cardano_block.go:137blockType, err := ledger.DetermineBlockType(blockCbor)
• cosmos/cardano-probabilistic-light-client-core/cardano_block.go:139decodedBlock, decodeErr := ledger.NewBlockFromCbor(blockType, blockCbor)

kupoblock-encodingera-identitytransaction-encoding

The gateway's Lucid provider reads UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• cardano/gateway/src/shared/modules/lucid/lucid.provider.ts:792`${kupoEndpoint}/matches/${queryPredicate}${isAddress ? '' : '/*'}?unspent`,

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

The gateway follows blocks and reads era summaries through Ogmios, and its Lucid provider submits, evaluates and reads parameters through it.

• cardano/gateway/src/shared/helpers/time.ts:213sendRequest('nextBlock');
• cardano/gateway/src/shared/helpers/time.ts:124ogmiosUrl, 'queryLedgerState/eraSummaries', {},
• cardano/gateway/src/shared/modules/lucid/lucid.provider.ts:456export async function evaluateTxWithOgmiosScriptRefFallback<T>(

blockfrostprotocol-parameters

Epoch history reads Blockfrost epoch parameters on public networks.

• cardano/gateway/src/query/services/yaci-history.service.ts:1647const url = new URL(`${endpoint}/epochs/${epoch}/parameters`);

cardano-multiplatform-lib-cmltransaction-encoding

The gateway decodes on-chain transaction bodies it did not build (packet evidence) with CML 6.2.0.

• cardano/gateway/src/query/services/query.service.ts:313const body = CML.TransactionBody.from_cbor_hex(evidence.txBodyCborHex);

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

cardano-services implements its chain-history, network-info, stake-pool, rewards and asset providers on db-sync. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• packages/cardano-services/src/ChainHistory/DbSyncChainHistory/DbSyncChainHistoryProvider.ts:35export class DbSyncChainHistoryProvider extends DbSyncProvider() implements ChainHistoryProvider {
• packages/cardano-services/src/NetworkInfo/DbSyncNetworkInfoProvider/DbSyncNetworkInfoProvider.ts:36export class DbSyncNetworkInfoProvider extends DbSyncProvider(RunnableModule) implements NetworkInfoProvider {

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

@cardano-sdk/ogmios is the node interface of cardano-services: chain-sync, submission, era summaries and ledger-state queries.

• packages/ogmios/src/CardanoNode/OgmiosCardanoNode.ts:75public async eraSummaries(): Promise<EraSummary[]> {

blockfrostera-identityprotocol-parameters

The Blockfrost network-info provider reads /network/eras and the epoch parameters.

• packages/cardano-services-client/src/NetworkInfoProvider/BlockfrostNetworkInfoProvider.ts:55public async protocolParameters(): Promise<Cardano.ProtocolParameters> {

ledgerjs-hw-app-cardanotransaction-encoding

Signs transactions built elsewhere (dApp requests or transaction files) on a Ledger: the Ledger key agent signs any body handed to it, including CIP-30 requests in Lace.

• packages/hardware-ledger/src/LedgerKeyAgent.ts:741async signTransaction(

kupoblock-encodingera-identitytransaction-encoding

The indexer tools query Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• src/lib/kupo.ts:24return kupoFetch<KupoMatch[]>(`/matches/${encodeURIComponent(pattern)}`);

blockfrostprotocol-parameters

The transaction builder reads Blockfrost's latest epoch parameters.

• src/modules/txbuilder/index.ts:28"/epochs/latest/parameters"

gouroborosnode-to-client-protocolblock-encoding

Its whole purpose is a node-to-client bridge (chain-sync, state query, tx monitor, tx submission) on gouroboros v0.202.7, which stops before V23. The repository is archived.

• internal/node/node.go:40ouroboros.WithNodeToNode(false),
• internal/node/node.go:42ouroboros.WithChainSyncConfig(buildChainSyncConfig(*connCfg)),

gouroborosera-identitytransaction-encodingplutus-languagestake-pool-registrationprotocol-parameters

Decodes submitted transactions and reads current protocol parameters through pre-Dijkstra ledger types.

• internal/utxorpc/submit.go:550txType, err := ledger.DetermineTransactionType(txRawBytes)
• internal/utxorpc/query.go:61protoParams, err := oConn.LocalStateQuery().Client.GetCurrentProtocolParams()

addernode-to-client-protocol

Chain-sync and UTxO RPC watch endpoints consume Adder pipeline events, and Adder's node-to-client input comes from a gouroboros release that cannot negotiate V23.

• internal/node/chainsync.go:21"github.com/blinklabs-io/adder/event"
• internal/utxorpc/watch.go:24"github.com/blinklabs-io/adder/event"

bloxbean-cardano-client-librarytransaction-encoding

Decodes transactions it did not build with cardano-client-lib, whose body ends at key 22 and languages at V3. (construction parse and combine take client-supplied transactions).

• api/src/main/java/org/cardanofoundation/rosetta/api/construction/service/CardanoConstructionServiceImpl.java:131DataItem dataItem = CborSerializationUtil.deserialize(decodeHexString(encoded));

cardano-serialization-lib-cslplutus-language

The construction API parses signed transactions with CSL; the repository is archived.

• cardano-rosetta-server/src/server/services/cardano-services.ts:458const parsed = scope.manage(CardanoWasm.Transaction.from_bytes(signedTransactionBytes));

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The Rosetta server answers from db-sync, including epoch parameters and pool registrations. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only. The repository is archived.

• cardano-rosetta-server/src/server/db/queries/blockchain-queries.ts:507FROM epoch_param
• cardano-rosetta-server/src/server/db/queries/blockchain-queries.ts:320FROM pool_update pu

cardano-serialization-lib-cslstake-pool-registrationtransaction-encoding

The construction API parses signed transactions with CSL, whose body decoder rejects keys beyond 22 and pool certificates with a BLS key; the repository is archived.

• cardano-rosetta-server/src/server/services/cardano-services.ts:458const parsed = scope.manage(CardanoWasm.Transaction.from_bytes(signedTransactionBytes));

kupoblock-encodingera-identitytransaction-encoding

The default Kupmios backend serves UTxO queries from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• src/Internal/Contract/Monad.purs:265buildCtlBackend { ogmiosConfig, kupoConfig } = do

ogmiosprotocol-parameterstransaction-encodingera-identity

The Kupmios backend reads protocol parameters and era summaries from Ogmios and submits through it.

• src/Internal/Contract/Monad.purs:33import Cardano.Kupmios.Ogmios (getProtocolParameters, getSystemStartTime)
• src/Contract/Backend/Ogmios.purs:9import Cardano.Kupmios.Ogmios (submitTxOgmios) as Ogmios

blockfrostprotocol-parameters

The Blockfrost backend reads protocol parameters.

• src/Internal/Contract/Monad.purs:312<$> withErrorOnLeft Blockfrost.getProtocolParameters

blockfrostera-identity

Slot and time conversion asks the active backend for era summaries; on the Blockfrost backend that is /network/eras.

• src/Contract/Time.purs:190liftedE $ liftAff $ provider.getEraSummaries

ouroboros-consensusblock-encodingera-identity

The node 11.1.x component set carries cardano-ledger-dijkstra 0.3.0.0, whose block body and header differ from the target.

• cabal.project:200 , ouroboros-consensus ==4.2.1.0

cardano-apicardano-api-haskellera-identitytransaction-encoding

cardano-api 11.6.0.0 is the node 11.1.x API; the wallet's Dijkstra handling is built on it.

• cabal.project:175 , cardano-api ==11.6.0.0

cardano-ledger-conwayera-identityprotocol-parameterstransaction-encodingtransaction-rules

The ledger set is the node 11.1.x one (conway 1.23.0.0), not the target.

• cabal.project:189 , cardano-ledger-conway ==1.23.0.0

blockfrostprotocol-parameters

Transaction building reads Blockfrost's latest epoch parameters.

• src/Wallet/index.js:1003const p = await private_blockfrostRequest( blockfrost_project_id,"/epochs/latest/parameters" );

cardano-walletnode-to-client-protocol

A client of the cardano-wallet REST API, which cannot connect to an 11.2 node; last pushed 2024-02.

• base.ts:19export const BASE_PATH = "https://localhost:8090/v2/".replace(/\/+$/, "");

own codetransaction-encoding

Stake registration certificates are encoded with the enum index, 0 for stakeRegistration and 1 for deregistration; Conway certificate types are not modelled. Dijkstra rejects deposit-less stake (de)registration certificates (types 0 and 1); on the devnet a Conway transaction carrying one is refused after the fork (cross-era-submission).

• lib/src/transaction/model/bc_certificate.dart:63CborList([CborSmallInt(type.index), credential.cborValue]);
• lib/src/transaction/model/bc_certificate.dart:27case 0: //BcCertificateType.stakeRegistration

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider reads UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• packages/cardano/src/providers/kupmios.ts:67const response = await getUnspent("/matches/{pattern}?unspent", {

ogmiosprotocol-parameterstransaction-encodingera-identityplutus-language

The Kupmios provider reads parameters, submits and evaluates through Ogmios; the Koios provider evaluates through Koios's Ogmios passthrough.

• packages/cardano/src/providers/kupmios.ts:48method: "queryLedgerState/protocolParameters",
• packages/cardano/src/providers/kupmios.ts:181method: "submitTransaction",
• packages/cardano/src/providers/kupmios.ts:163method: "evaluateTransaction",

koiosprotocol-parameters

The Koios provider reads /epoch_params for transaction building.

• packages/cardano/src/providers/koios.ts:30const response = await koiosClient.GET("/epoch_params", {

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

CardanoKit's Maestro data provider fetches protocol parameters from Maestro.

• Sources/CardanoKit/Provider/Maestro/MaestroDataProvider.swift:45path: "/v1/protocol-parameters",

cardano-multiplatform-lib-cmlblock-encodingera-identitytransaction-encoding

Indexes chain blocks with CML's multi-era decoder, which ends at Conway.

• indexer/src/sinks/cardano.rs:283let multi_block = MultiEraBlock::from_explicit_network_cbor_bytes(&block_payload).unwrap();

ourablock-encodingera-identitytransaction-encoding

The indexer's chain source is Oura (pinned by git revision), whose Pallas decoder ends at Conway; Carp indexes whatever blocks Oura hands it.

• indexer/Cargo.toml:32oura = { git = "https://github.com/txpipe/oura.git"
• indexer/src/sources/oura_source.rs:10use oura::pipelining::SourceProvider;

own codeblock-encoding

The gateway indexes every chain block as cardano-chain-follower's MultiEraBlock, which wraps Pallas's multi-era block (the crate re-exports pallas_traverse and pallas_primitives); no Pallas revision decodes Dijkstra blocks (devnet pallas-chain-sync). The repository commits no Cargo.lock, so the link is read from these imports.

• catalyst-gateway/bin/src/db/index/block/certs.rs:6MultiEraBlock, Slot, StakeAddress, TxnIndex, VKeyHash,
• catalyst-gateway/bin/src/db/index/block/certs.rs:8pallas_traverse::{MultiEraCert, MultiEraTx},
• catalyst-gateway/bin/Cargo.toml:18cardano-chain-follower = { version = "0.0.19"

own codeplutus-language

The app's serialization library maps a reference script's tag through RefScriptType.values, which ends at PlutusV3 (3); a UTxO carrying a PlutusV4 reference script (tag 4) throws a range error when read.

• catalyst_voices/packages/libs/catalyst_cardano_serialization/lib/src/scripts.dart:520final type = RefScriptType.values[(value[0] as CborSmallInt).toInt()];
• catalyst_voices/packages/libs/catalyst_cardano_serialization/lib/src/scripts.dart:309plutusV3(3);

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The validation module fetches epoch parameters, pools and rewards from db-sync to check the calculation. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• validation/src/main/java/org/cardanofoundation/rewards/validation/entity/dbsync/DbSyncProtocolParameters.java:12@Table(name = "epoch_param")
• validation/src/main/java/org/cardanofoundation/rewards/validation/entity/dbsync/DbSyncPoolOwner.java:13@Table(name = "pool_owner")

koiosprotocol-parameters

The Koios data fetcher reads protocol parameters for the reward calculation through koios-java-client.

• validation/pom.xml:98<artifactId>koios-java-client</artifactId>

yacinode-to-client-protocol

The optional node-socket path for current protocol parameters runs on yaci 0.3.4.1, before V23 (v0.3.10).

• gradle/libs.versions.toml:2yaci = "com.bloxbean.cardano:yaci:0.3.4.1"
• config/application.properties:40# local Cardano node using node-to-client protocol

bloxbean-cardano-client-libraryplutus-language

On-chain scripts are mapped to cardano-client-lib's PlutusScript types, which stop at V3.

• application/src/main/java/org/cardanofoundation/ledgersync/factory/PlutusScriptFactory.java:32public Script handle(PlutusScript plutusScript, Tx tx) {

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider queries UTxOs from Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• src/Chrysalis.Tx/Providers/Kupmios.cs:66// Query each address individually using the /matches/{address} endpoint

ogmiostransaction-encodingera-identity

The Kupmios provider submits through Ogmios.

• src/Chrysalis.Tx/Providers/Kupmios.cs:279method = "submitTransaction",

ogmiosplutus-language

The Blockfrost provider evaluates through Blockfrost's evaluate endpoint, which Blockfrost answers through Ogmios.

• src/Chrysalis.Tx/Providers/Blockfrost.cs:443new Uri("utils/txs/evaluate", UriKind.Relative), content).ConfigureAwait(false);

blockfrostprotocol-parameters

The Blockfrost provider reads /epochs/latest/parameters.

• src/Chrysalis.Tx/Providers/Blockfrost.cs:82const string query = "epochs/latest/parameters";

pallasblock-encodingera-identity

Chain sync decodes each header from the node with MultiEraHeader::decode, from a pinned Pallas revision without Dijkstra.

• src/nodeclient/sync/mod.rs:221MultiEraHeader::decode(content.variant, None, &content.cbor)
• Cargo.toml:16pallas-traverse = { git = "https://github.com/txpipe/pallas", rev = "d1dfe10e2bac83c7d3b5371a72814354a5acd1ba" }

blockfrostprotocol-parameters

The Blockfrost provider reads /epochs/latest/parameters.

• src/provider/BlockfrostProvider.ts:279const query = 'epochs/latest/parameters';

blockfrostprotocol-parameters

Online validation fetches the validation context, including protocol parameters, from Blockfrost or Koios through cquisitor-lib.

• src/app/TransactionValidatorContent.tsx:1303await validateTransactionOnline({

koiosprotocol-parameters

Online validation fetches the validation context, including protocol parameters, from Blockfrost or Koios through cquisitor-lib.

• src/app/TransactionValidatorContent.tsx:1303await validateTransactionOnline({

cquisitor-libera-identityplutus-languagetransaction-encoding

Decodes and validates arbitrary user-supplied transactions with cquisitor-lib.

• src/app/TransactionValidatorContent.tsx:1303await validateTransactionOnline({

cardano-serialization-lib-cslplutus-language

A transaction decoder and validator: it decodes arbitrary transactions with CSL.

• src/csl_decoders/specific_decoders.rs:20let fixed_tx = csl::FixedTransaction::from_hex(input)

blockfrostprotocol-parameters

The Blockfrost client reads epoch parameters for validation.

• ts/chain/blockfrostClient.ts:781epochNo !== undefined ? `/epochs/${epochNo}/parameters` : "/epochs/latest/parameters";

koiosprotocol-parameters

The Koios client reads /epoch_params for validation.

• ts/chain/koiosClient.ts:362const endpoint = epochNo !== undefined ? `/epoch_params?_epoch_no=${epochNo}` : '/epoch_params';

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

A transaction decoder and validator: arbitrary transactions go through CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key.

• src/csl_decoders/specific_decoders.rs:20let fixed_tx = csl::FixedTransaction::from_hex(input)

koiosprotocol-parameters

The template's API route builds transactions with Lucid Evolution on its Koios provider, which reads Koios epoch parameters.

• src/pages/api/transaction.ts:8return Lucid(new Koios("https://preprod.koios.rest/api/v1"), "Preprod");

koiosprotocol-parameters

query protocol-parameters and transaction building read Koios epoch parameters.

• Src/ConsoleTool/Query/QueryProtocolParametersCommand.cs:24var protocolParams = await epochClient.GetProtocolParameters(null, limit:1).ConfigureAwait(fa

cardano-serialization-lib-cslplutus-language

The React Native binding re-exports CSL's cost-model and transaction API, so every consumer inherits the PlutusV3 ceiling.

• rust/src/c_bridge/bridge.rs:46use cardano_serialization_lib::Costmdls;
• rust/src/c_bridge/bridge.rs:68use cardano_serialization_lib::FixedTransaction;

cardano-serialization-lib-cslblock-encodingprotocol-parametersstake-pool-registrationtransaction-encoding

The React Native binding re-exports CSL's block, transaction, certificate and parameter-update decoders, so every consumer inherits their Conway ceilings.

• rust/src/c_bridge/bridge.rs:46use cardano_serialization_lib::Costmdls;
• rust/src/c_bridge/bridge.rs:68use cardano_serialization_lib::FixedTransaction;

cardano-walletnode-to-client-protocol

Daedalus runs on cardano-wallet's REST API; the bundled wallet backend cannot connect to an 11.2 node.

• source/renderer/app/api/wallets/requests/createWallet.ts:16path: '/v2/wallets',

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

Dandelion deploys db-sync and the public APIs built on it (Koios, Blockfrost RYO, GraphQL, Rosetta). db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• base/cardano-db-sync/configmap.yaml:83select distinct pool_hash.id, pool_hash.view, encode(pool_update.vrf_key_hash, 'hex') from pool_update

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

Dandelion deploys a public Ogmios endpoint (Ogmios v5.5.6 with node 8.1.2 in the base manifests).

• base/ogmios/deployment.yaml:41image: cardanosolutions/ogmios:v5.5.6-mainnet

kupoblock-encodingera-identitytransaction-encoding

Dandelion deploys a public Kupo endpoint. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• base/kupo/statefulset.yaml:32image: cardanosolutions/kupo

koiosprotocol-parameters

The debugger fills script contexts from Koios /cli_protocol_params, which Koios serves Conway-only.

• src/data-providers/koios-client.ts:62const response = await this.makeRequest<KoiosCliProtocolParams>('GET', network, '/cli_protocol_param

aikenplutus-languageplutus-script-context

The debugger builds a transaction's script context with its Aiken uplc fork, which has no PlutusV4 context.

• rust-src/Cargo.toml:10uplc = { git = "https://github.com/cardananium/aiken/", branch = "de-uplc" }
• rust-src/src/debugger_engine/debugger_engine.rs:12script_context::{

koiosprotocol-parameters

The debugger fills script contexts from Koios /cli_protocol_params, which Koios serves Conway-only.

• packages/core/src/data-providers/koios-client.ts:69const response = await this.makeRequest<KoiosCliProtocolParams>('GET', network, '/cli_protocol_param

aikenplutus-languageplutus-script-context

The web debugger's engine builds a transaction's script context with an Aiken uplc fork, which has no PlutusV4 context.

• packages/engine-wasm/crate/Cargo.toml:10uplc = { git = "https://github.com/cardananium/aiken", rev = "775e949829e27f8d619c14dbf49d0f41b5489a4e" }
• packages/engine-wasm/crate/src/context.rs:41pub fn from_uplc_context(context: &uplc::machine::Context) -> Self {

kupoblock-encodingera-identitytransaction-encoding

The Kupo data provider reads pool UTxOs and datums from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• src/providers/data/kupo-provider.ts:50: `/matches/${address}?unspent`;

gouroborosera-identity

Transactions submitted over UTxO RPC go through gouroboros's era detection, which rejects ordinary Dijkstra transactions.

• api/utxorpc/submit.go:86txType, err := safedecode.TransactionType(txRawBytes)

gouroborosblock-encoding

Chain-sync decodes block headers with gouroboros, which requires the twelve-field Dijkstra header that the tagged node 11.2.0 does not emit.

• ouroboros/chainsync.go:3626header, err = gledger.NewBlockHeaderFromCbor(blockType, raw)

pallasblock-encodingera-identity

Dolos decodes the blocks it archives and serves with MultiEraBlock::decode; it pins Pallas 1.3.0, whose traversal has no Dijkstra era even with unstable.

• crates/fjall/src/archive/mod.rs:1189MultiEraBlock::decode(&body).map_err(ArchiveError::BlockDecodingError)?;
• Cargo.toml:231pallas = { version = "1.3.0", features = ["hardano", "phase2", "unstable"] }

blockfrostprotocol-parameters

The dApp's Mesh proxy builds from Blockfrost epoch parameters.

• code/dApp/src/lib/mesh/protocol-parameter-cache.ts:42const raw = parseBuildParameters(await provider.get(`epochs/${key}/parameters`));

ogmiosplutus-languagetransaction-encoding

The Mesh proxy forwards evaluateTx and submitTx to the Blockfrost provider, which evaluates through Ogmios.

• code/dApp/src/app/api/mesh/route.ts:88if (payload.method === "evaluateTx" || payload.method === "submitTx") {

scalusplutus-script-contexttransaction-encoding

The scalus-uplc evaluator calls Scalus for ex-unit evaluation.

• packages/scalus-uplc/src/Evaluator.ts:98try: () => ScalusLib.Scalus.evalPlutusScripts(txBytes, utxosBytes, slotConfig, costModels),

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider reads UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• packages/evolution/src/sdk/provider/internal/KupmiosEffects.ts:216pattern = `${kupoUrl}/matches/${addressStr}?unspent`

ogmiosprotocol-parameterstransaction-encodingera-identityplutus-language

The Kupmios provider reads parameters, submits and evaluates through Ogmios.

• packages/evolution/src/sdk/provider/Kupmios.ts:37getProtocolParameters: () => KupmiosEffects.getProtocolParametersEffect(this.ogmiosUrl, this.headers)
• packages/evolution/src/sdk/provider/Kupmios.ts:45evaluateTx: KupmiosEffects.evaluateTxEffect(this.ogmiosUrl, this.headers),

blockfrostprotocol-parameters

The Blockfrost provider reads /epochs/latest/parameters.

• packages/evolution/src/sdk/provider/internal/BlockfrostEffect.ts:230`${baseUrl}/epochs/latest/parameters`,

koiosprotocol-parameters

The Koios provider reads /epoch_params.

• packages/evolution/src/sdk/provider/internal/KoiosEffect.ts:38const url = `${baseUrl}/epoch_params?limit=1&order=epoch_no.desc`

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

Ships a Maestro provider as a client option; Maestro is deprecated, so that provider path needs another backend.

• packages/evolution/src/sdk/client/internal/Providers.ts:20new Maestro.MaestroProvider(config.baseUrl, config.apiKey, config.turboSubmit)

own codetransaction-encoding

Debugging a transaction by id fetches its CBOR from Blockfrost and decodes it with Pallas's Conway MintedTx, which cannot read the Dijkstra three-element form or its new body keys.

• gastronomy/src/uplc.rs:114let multi_era_tx = MintedTx::decode_fragment(&tx_bytes).unwrap();
• gastronomy/src/chain_query.rs:137let tx_bytes = hex::decode(value["cbor"].as_str().unwrap())?;

own codeplutus-language

Reference scripts of the inputs are rebuilt from Blockfrost's script type with arms for PlutusV1-V3 only; a PlutusV4 reference script has no case.

• gastronomy/src/chain_query.rs:214let script = match script_version {
• gastronomy/src/chain_query.rs:221Type::PlutusV3 => {

aikenplutus-languageplutus-script-context

Script contexts for the debugged transaction are built by Aiken's uplc crate (tx_to_programs), which has no PlutusV4 context.

• gastronomy/Cargo.toml:24uplc = { git = "https://github.com/SundaeSwap-finance/aiken.git", rev = "8416725" }
• gastronomy/src/uplc.rs:149tx_to_programs(&tx, &resolved_inputs, &slot_config, script_overrides).unwrap()

koiosprotocol-parameters

Live protocol parameters are taken from Koios /epoch_params as the source of truth.

• src/api/liveProtocolParams.ts:4* Source of truth: Koios epoch_params (no project_id). Cached in protocol_params.

blockfrostprotocol-parameters

The Blockfrost node reads latest epoch parameters for transaction building.

• node/blockfrost.go:67params, err := b.client.LatestEpochParameters(context.TODO())

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The default chain-data provider reads governance, epoch parameters and pools from db-sync. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• govtool/govtool-provider-dbsync/scripts/live-committee-pools.mjs:389AND NOT EXISTS (SELECT 1 FROM pool_update pu WHERE pu.hash_id = ph.id AND
• govtool/frontend/src/context/wallet.tsx:751const costs = (await requireEpochParams()).cost_model?.costs;

blockfrostera-identityprotocol-parameters

The Blockfrost provider derives the era and protocol parameters from Blockfrost epoch parameters.

• govtool/govtool-provider-blockfrost/src/network.ts:4* getNetworkInfo /blocks/latest, /epochs/latest/parameters (era), /genesi

koiosprotocol-parameters

The Koios provider reads /epoch_params.

• govtool/govtool-provider-koios/src/accounts.ts:83'epoch_params',

koiosprotocol-parameters

CNTools in light mode takes protocol parameters from Koios /cli_protocol_params.

• scripts/cnode-helper-scripts/env:809if ! PROT_PARAMS=$(curl -sSL -f -X GET "${KOIOS_API_HEADERS[@]}" "${KOIOS_API}/cli_protocol_params" 2>&1); then

ogmiostransaction-encodingera-identity

CNTools light mode submits transactions through Koios's Ogmios passthrough.

• scripts/cnode-helper-scripts/cntools.library:5224stdout=$(curl -sSL -X POST "${HEADERS[@]}" -d "${jsonrpc}" "${KOIOS_API}/ogmios/" 2>&1)

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The suite ships db-sync configurations and the Koios gRest deployment that runs on db-sync. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• files/configs/mainnet/db-sync-config.json:19"tx_out": {

cardano-apicardano-api-haskellera-identitytransaction-encoding

The direct chain follower connects through cardano-api ^>=11.7 and stops on an unknown era.

• hydra-node/src/Hydra/Chain/Direct.hs:277| EraNotSupportedYet {otherEraName :: Text}

blockfrostera-identityprotocol-parameters

The Blockfrost chain backend reads /network/eras for time conversion and the latest epoch parameters.

• hydra-node/src/Hydra/Chain/Blockfrost/Client.hs:472eras' <- Blockfrost.getNetworkEras
• hydra-node/src/Hydra/Chain/Blockfrost/Client.hs:206pparams <- Blockfrost.getLatestEpochProtocolParams

cardano-serialization-lib-cslplutus-language

The offline evaluator decodes arbitrary transactions and the builder constructs Plutus scripts from a language value through CSL.

• packages/evaluator/src/context/resolver.ts:125tx = CardanoWASM.Transaction.from_hex(txHex)
• packages/hydra-transaction/src/tx-builder/index.ts:245const plutusScript = CardanoWASM.PlutusScript.from_hex_with_version(scriptCbor, language)

ogmiostransaction-encodingera-identity

The Ogmios provider submits transactions through Ogmios.

• packages/core/src/utils/providers/ogmios.provider.ts:140const response = await this.rpcRequest<{ result: { transaction: { id: string } } }>('submitTransaction', {

whiskytransaction-encodingplutus-language

The evaluator package hands arbitrary transaction hex to whisky-evaluator's js_evaluate_tx_scripts, which decodes Conway bodies only and does not evaluate PlutusV4.

• packages/evaluator/src/engine/whisky.ts:36const WHISKY_PACKAGE = 'whisky-evaluator'
• packages/evaluator/src/engine/whisky.ts:97if (!mod || typeof mod.js_evaluate_tx_scripts !== 'function') {

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

The offline evaluator decodes arbitrary transactions with CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key.

• packages/evaluator/src/context/resolver.ts:125tx = CardanoWASM.Transaction.from_hex(txHex)
• packages/hydra-transaction/src/tx-builder/index.ts:245const plutusScript = CardanoWASM.PlutusScript.from_hex_with_version(scriptCbor, language)

blockfrostprotocol-parameters

The plugin builds transactions with cardano-client-lib's QuickTxBuilder on the Blockfrost backend, which reads Blockfrost epoch parameters.

• src/main/java/com/bloxbean/intelliada/idea/nodeint/service/impl/TransactionServiceImpl.java:108var txContext = new QuickTxBuilder(backendService)

ogmiosblock-encodingtransaction-encodingera-identity

The Indigo indexer follows the chain through Ogmios chain-sync.

• src/IndexerApplication.ts:27import { ChainSynchronization } from '@cardano-ogmios/client';

bloxbean-cardano-client-librarytransaction-encodingplutus-language

Decodes transactions it did not build with cardano-client-lib, whose body ends at key 22 and languages at V3. (the transaction evaluator).

• julc-cardano-client-lib/src/main/java/org/julclang/clientlib/eval/JulcTransactionEvaluator.java:194Transaction tx = Transaction.deserialize(cbor);

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

Kogmios is a Kotlin Ogmios client: chain-sync, submission, evaluation, parameters and era queries.

• src/main/kotlin/io/newm/kogmios/ChainSyncClient.kt:23suspend fun nextBlock(timeoutMs: Long = DEFAULT_REQUEST_TIMEOUT_MS): MsgNextBlockResponse
• src/main/kotlin/io/newm/kogmios/ClientImpl.kt:426override suspend fun protocolParameters(timeoutMs: Long): MsgQueryProtocolParametersResponse {

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

Koios gRest is SQL over db-sync, including epoch_param and pool registrations. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• files/grest/rpc/000_utilities/is_dangling_delegation.sql:11SELECT INTO curr_epoch MAX(epoch_param.epoch_no) FROM public.epoch_param;

koiosera-identityprotocol-parameters

The CLI wraps /tip, whose era comes from Koios's era_map, and /epoch_params.

• internal/api/network.go:29cmd := happy.NewCommand("tip",
• internal/api/epoch.go:68cmd := happy.NewCommand("epoch_params",

koiosprotocol-parameters

The client wraps /epoch_params.

• epoch.go:190func (c *Client) GetEpochParams(

koiosera-identityprotocol-parameters

The client wraps /epoch_params and exposes the era field Koios fills from era_map.

• src/main/java/rest/koios/client/backend/api/epoch/impl/EpochServiceImpl.java:59public Result<EpochParams> getLatestEpochParameters() throws ApiException {
• src/main/java/rest/koios/client/backend/api/block/model/BlockInfo.java:118private String era;

koiosera-identityprotocol-parameters

The client wraps /tip, whose era comes from Koios's era_map, and /epoch_params.

• koios_python/network.py:10def get_tip(self):
• koios_python/epoch.py:62def get_epoch_params(self, epoch_no=None):

ouroboros-consensusblock-encodingera-identity

The consensus pin fixes an earlier ledger whose Dijkstra block body and header differ from the target (R2: cardano-ledger-dijkstra 0.2.0.1).

• cabal.project:21 , any.ouroboros-consensus == 3.0.1.0

cardano-apicardano-api-haskellera-identitytransaction-encoding

Fee and ex-unit endpoints dispatch on Babbage and Conway only, on cardano-api 11.0.

• kuber-server/src/Kuber/Server/Core.hs:59_ -> kError FeatureNotSupported ("calculateMinFee: only BabbageEra and ConwayEra supported got : " ++ show cera)

ouroboros-consensusblock-encodingera-identity

The consensus pin fixes an earlier ledger whose Dijkstra block body and header differ from the target (R2: cardano-ledger-dijkstra 0.2.0.1).

• cabal.project:53 , any.ouroboros-consensus ^>= 3.0.1

ogmiosblock-encodingera-identitytransaction-encoding

Kupo can follow the chain through Ogmios chain-sync instead of a node socket.

• src/Kupo/App/ChainSync/Ogmios.hs:5module Kupo.App.ChainSync.Ogmios

cardano-js-sdkprotocol-parameters

The signer decodes transactions with @cardano-sdk/core 0.47.1, whose protocol-parameter updates stop at key 37; proposals touching keys 38-56 cannot be read.

• packages/contract/cardano-context/src/signing/cardano-in-memory-transaction-signer.ts:69const tx = Serialization.Transaction.fromCbor(

blockfrostera-identityprotocol-parameters

The Blockfrost network-info provider reads /network/eras and epoch parameters for transaction building.

• packages/lib/cardano-provider-core/src/provider/blockfrost-network-info-provider.ts:117return await this.request<Responses['network-eras

ogmiosplutus-languagetransaction-encoding

Script evaluation goes to Blockfrost's evaluate endpoint, which Blockfrost answers through Ogmios.

• packages/lib/cardano-provider-core/src/provider/blockfrost-tx-evaluation-provider.ts:17// Blockfrost `POST /utils/txs/evaluate` — Ogmios' EvaluateTx

ledgerjs-hw-app-cardanotransaction-encoding

Signs transactions built elsewhere (dApp requests or transaction files) on a Ledger for CIP-30 dApp requests.

• packages/lib/util-hw/src/mobile/ledger-ble-service.ts:1import LedgerConnection from '@cardano-foundation/ledgerjs-hw-app-cardano';

pallasblock-encodingera-identity

The CBOR inspector still decodes pasted blocks and transactions with Pallas multi-era traversal, now explicitly pinned at 296b43f3. That traversal does not provide the target Dijkstra decoder.

• napi-pallas/src/block.rs:14let block = MultiEraBlock::decode(&cbor)?;
• napi-pallas/src/tx.rs:248MultiEraTx::decode(&cbor)
• napi-pallas/Cargo.toml:15pallas = { git = "https://github.com/txpipe/pallas.git", rev = "296b43f33a13abc6a1166b7851741bf57441c86d", features = ["applying"] }

own codetransaction-encoding

The transaction builder's stake registration certificate is the deposit-less type 0. Dijkstra rejects deposit-less stake (de)registration certificates (types 0 and 1); on the devnet a Conway transaction carrying one is refused after the fork (cross-era-submission).

• include/cardano/ledger.hpp:767static constexpr auto TypeTag() -> Uint { return 0; }
• src/babbage/transaction.cpp:165auto cert = babbage::StakeRegistration{};
• include/cardano/ledger.hpp:1564using StakeRegistration = shelley::StakeRegistration;

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider reads UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• lib/provider/kupmios.ts:195`${this.kupoUrl}/datums/${datumHash}`,

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

Lucid's Maestro provider fetches protocol parameters and submits through Maestro's transaction manager.

• lib/provider/maestro.ts:38const timestampedResult = await fetch(`${this.url}/protocol-parameters`, {
• lib/provider/maestro.ts:252let queryUrl = `${this.url}/txmanager`;

scalusplutus-script-contexttransaction-encoding

The scalus-uplc evaluator loads Scalus for ex-unit evaluation, which does not implement PlutusV4.

• packages/scalus-uplc/src/index.ts:19const loadScalus = (): Promise<Scalus> => (scalusModule ??= import("scalus"));

kupoblock-encodingera-identitytransaction-encoding

The Kupmios provider reads UTxOs and datums from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• packages/provider/src/kupmios.ts:236const pattern = `${this.kupoUrl}/matches/${queryPredicate}${isAddress ? "" : "/*"}?unspent&resolve_hashes`;

ogmiosprotocol-parameterstransaction-encodingera-identityplutus-language

The Kupmios provider reads parameters, submits and evaluates through Ogmios; the Koios provider evaluates through Koios's Ogmios passthrough.

• packages/provider/src/kupmios.ts:165method: "queryLedgerState/protocolParameters",
• packages/provider/src/kupmios.ts:483method: "submitTransaction",
• packages/provider/src/kupmios.ts:526method: "evaluateTransaction",

blockfrostprotocol-parameters

The Blockfrost provider reads /epochs/latest/parameters.

• packages/provider/src/blockfrost.ts:85const result = await this.fetch(`${this.url}/epochs/latest/parameters`, {

koiosprotocol-parameters

The Koios provider reads /epoch_params.

• packages/provider/src/koios.ts:78const url = `${this.baseUrl}/epoch_params?limit=1`;

cardano-multiplatform-lib-cmltransaction-encoding

fromTx decodes any transaction CBOR with the vendored CML, which stops at body key 22.

• packages/lucid/src/lucid-evolution/LucidEvolution.ts:223CML.Transaction.from_cbor_hex(tx),

cardano-apicardano-api-haskellera-identitytransaction-encoding

Indexes from a node chain-sync connection through cardano-api ^>=8.20.

• marconi-cardano-core/cardano-api-extended/src/Cardano/Api/Extended/Streaming.hs:97withAsync (connectToLocalNodeWithChainSyncClient localNodeConnectInfo client) $ \a -> do

cardano-apicardano-api-haskellera-identitytransaction-encoding

The indexer follows the node through cardano-api ^>=11.0, which has no target Dijkstra era.

• marlowe-indexer/src/Marlowe/Indexer/NodeFollower.hs:216C.connectToLocalNode localNodeConnectInfo $

cardano-serialization-lib-cslplutus-language

Hydra integration decodes head transactions produced by other parties with CSL.

• src/lib/hydra/hydra/node-fanout-references.ts:41const transaction = FixedTransaction.from_bytes(Buffer.from(confirmedProducer.cborHex, 'hex'));

blockfrostprotocol-parameters

The payment service builds transactions with Mesh's Blockfrost provider, which reads Blockfrost epoch parameters.

• packages/payment-source-v1/src/services/purchases/x402-build/service.ts:171const protocolParameters = await blockchainProvider.fetchProtocolParameters(Number.NaN);

ogmiosplutus-languagetransaction-encoding

Registration estimates execution units with the Blockfrost provider's evaluateTx, which Blockfrost answers through Ogmios.

• packages/payment-source-v1/src/services/registry/register/service.ts:243const estimatedFee = (await blockchainProvider.evaluateTx(evaluationTx)) as Array<{

cardano-serialization-lib-csltransaction-encoding

Hydra integration decodes head transactions produced by other parties with CSL, whose body decoder rejects keys beyond 22.

• src/lib/hydra/hydra/node-fanout-references.ts:41const transaction = FixedTransaction.from_bytes(Buffer.from(confirmedProducer.cborHex, 'hex'));

scalusplutus-script-contexttransaction-encoding

The offline evaluator calls Scalus for ex-unit evaluation.

• packages/mesh-core-cst/src/offline-providers/offline-evaluator-scalus.ts:148return evalPlutusScripts(

cardano-js-sdkprotocol-parameters

Governance proposals are converted to @cardano-sdk/core 0.46.12 parameter updates, which stop at key 37.

• packages/mesh-core-cst/src/utils/proposal.ts:94const toCardanoProtocolParamUpdate = (

whiskytransaction-encoding

The CSL core parses transaction bodies with Whisky, which decodes through CSL (body ends at key 22).

• packages/mesh-core-csl/src/parser/index.ts:1import { js_parse_tx_body, JsVecString } from "@sidan-lab/whisky-js-nodejs";

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The extension catalog deploys db-sync for operators. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• catalog/extension-catalog.json:2476"id": "cardano-db-sync",

cardano-apicardano-api-haskellera-identitytransaction-encoding

Off-chain transaction builders are typed to the Conway era on cardano-api ==10.21.0.0.

• offchain/src/Midgard/Contracts/Init.hs:37(MonadError String m, MonadBlockchain C.ConwayEra m) =>

kupoblock-encodingera-identitytransaction-encoding

The L1 services stack runs Kupo for the Midgard node's Kupmios provider, which reads L1 UTxOs from it. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• l1-services/docker-compose.yml:90image: cardanosolutions/kupo:v2.9.0

ogmiosprotocol-parameterstransaction-encodingera-identityplutus-language

The node's Kupmios provider reads parameters, submits and evaluates through the stack's Ogmios (v6.11.0).

• l1-services/docker-compose.yml:71image: cardanosolutions/ogmios:v6.11.0

ogmiosblock-encodingera-identitytransaction-encoding

The syncer follows pool updates through Ogmios chain-sync.

• src/syncer/syncer.ts:36const ogmiosClient = await Ogmios.createChainSynchronizationClient(

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

The Maestro adapter reads pool UTxOs and asset information from Maestro to build swaps.

• src/adapters/maestro.ts:74const utxos = await this.maestroClient.addresses.utxosByPaymentCred(

pallasblock-encodingera-identity

The Cardano chain reader decodes every block it pulls from the node with MultiEraBlock::decode from Pallas 1.4.0, which has no Dijkstra era.

• internal/cardano-node/mithril-cardano-node-chain/src/chain_reader/pallas_chain_reader.rs:298let multi_era_block = MultiEraBlock::decode(&raw_block)
• internal/cardano-node/mithril-cardano-node-chain/Cargo.toml:26pallas-network = { version = "1.4.0" }

pallasblock-encodingera-identity

The Postgres extension's functions decode stored block CBOR with MultiEraBlock::decode from Pallas 0.31.0, so Dijkstra blocks return errors.

• extension/src/lib.rs:26let block = match MultiEraBlock::decode(block_cbor) {
• extension/Cargo.toml:21pallas = "0.31.0"

cardano-js-sdkprotocol-parameters

Decodes dApp-supplied transactions with @cardano-sdk/core ^0.39.2; the repository is archived.

• src/api/extension/index.js:48const tx = Serialization.Transaction.fromCbor(cbor);

blockfrostprotocol-parameters

Transaction building reads Blockfrost's latest epoch parameters. The repository is archived.

• src/api/extension/wallet.js:20const p = await blockfrostRequest(`/epochs/latest/parameters`);

ledgerjs-hw-app-cardanotransaction-encoding

Signs transactions built elsewhere (dApp requests or transaction files) on a Ledger for CIP-30 dApp requests. The repository is archived.

• src/api/extension/index.js:37import Ada, { HARDENED } from '@cardano-foundation/ledgerjs-hw-app-cardano';

cardano-hw-interop-libtransaction-encoding

Decodes and transforms dApp transactions for hardware signing with the interop library, which rejects bodies with keys beyond 22.

• src/api/extension/wallet.js:5import { decodeTx, encodeTx, transformTx } from 'cardano-hw-interop-lib';

cardano-multiplatform-lib-cmlblock-encodingera-identityplutus-languageprotocol-parametersstake-pool-registrationtransaction-encoding

Decodes dApp-supplied transactions with CML for CIP-30 signing. The repository is archived.

• src/api/loader.js:1import * as wasm from '@dcspark/cardano-multiplatform-lib-browser';

ogmiosplutus-languagetransaction-encodingera-identity

The Ogmios/Scrolls ledger client evaluates and submits transactions through Ogmios.

• src/trireme_ledger_client/cml_client/ogmios_scrolls_ledger.rs:161let res = self.ogmios_client.evaluate_tx(&bytes, vec![]).await?;
• src/trireme_ledger_client/cml_client/ogmios_scrolls_ledger.rs:168let res = self.ogmios_client.submit_tx(&bytes).await?;

cardano-db-syncblock-encodingera-identityprotocol-parametersstake-pool-registrationtransaction-encoding

The API and minting services query db-sync through an EF Core model that maps epoch_param, pool and transaction tables. db-sync cannot index Dijkstra blocks (R2 gap), so these queries return pre-fork data only.

• NMKR.Api/Startup.cs:57GlobalFunctions.optionsBuilderDbSync.UseNpgsql(connectionStringDbSync);
• NMKR.Shared/DbSyncModel/DbSyncContext.cs:412entity.ToTable("epoch_param");

koiosprotocol-parameters

Koios /epoch_params is a protocol-parameter source for minting transactions.

• NMKR.Shared/Functions/Koios/KoiosFunctions.cs:924string url = (tip == null || tip.Epoch==null)? $"{GeneralConfigurationClass.KoiosApi}/epoch_params" : $"{GeneralConfigurationClass.KoiosApi}/epoch_params?_epoch_no={tip.Epoch}";

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

The shared NMKR functions read UTxOs from Maestro and submit turbo transactions through it.

• NMKR.Shared/Functions/Meastro/MaestroFunctions.cs:18GeneralConfigurationClass.MaestroConfiguration.ApiUrl}/addresses/{address}/utxos
• NMKR.Shared/Functions/Meastro/MaestroFunctions.cs:113private static async Task<SubmissionResultClass> SubmitTurboTransactionAsync(byte[] signedTx)

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

The Ogmios backend follows the chain, evaluates, submits and reads protocol parameters through Ogmios.

• srv/blockchain/backends/ogmios-backend.ts:1226const handlers: Parameters<typeof createChainSynchronizationClient>[1] = {
• srv/blockchain/backends/ogmios-backend.ts:913const results = await this.txSubmissionClient!.evaluateTransaction(unsignedTxCbor);
• srv/blockchain/backends/ogmios-backend.ts:930async getProtocolParameters(): Promise<LedgerProtocolParameters> {

blockfrostprotocol-parameters

The Blockfrost backend reads latest epoch parameters.

• srv/blockchain/backends/blockfrost-backend.ts:442const protocolParams = await this.api.epochsLatestParameters();

koiosprotocol-parameters

The Koios backend reads /cli_protocol_params.

• srv/blockchain/backends/koios-backend.ts:910this.api.get('/cli_protocol_params'),

ouroboros-consensusblock-encodingera-identity

The consensus pin fixes an earlier ledger whose Dijkstra block body and header differ from the target (R2: cardano-ledger-dijkstra 0.2.0.1).

• server/cabal.project:21 , any.ouroboros-consensus ^>= 3.0.1

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

A .NET Ogmios client generated from the Ogmios v6.10 schema: chain-sync, submission, evaluation and ledger-state queries.

• src/Ogmios.Services/TransactionSubmission/TransactionSubmissionService.cs:20var paramsValue = Generated.Ogmios.SubmitTransaction.RequiredTransaction.Create(

ogmiosblock-encodingera-identitytransaction-encoding

The worker follows the chain through the Ogmios chain-sync service.

• src/BlockchainEvents.Worker/BlockchainEventsWorker.cs:47await chainSync.ResumeAsync(_checkpoint?.Slot, _checkpoint?.BlockHash, stoppingToken)

pallasblock-encodingera-identity

The node-to-node source decodes every header with MultiEraHeader::decode and the parse_cbor filter decodes blocks with MultiEraBlock::decode, through Pallas 1.1.

• src/sources/n2n.rs:44MultiEraHeader::decode(header.variant, Some(subtag), &header.cbor)
• src/filters/parse_cbor.rs:48trv::MultiEraBlock::decode(&cbor)
• Cargo.toml:48pallas = { version = "1.1", features = ["hardano"] }

blockfrostprotocol-parameters

The verifier submitter builds transactions from Blockfrost's latest epoch parameters.

• aiken-verifier/submitter/src/api.rs:86let url = format!("{}/epochs/latest/parameters", BLOCKFROST_API);

blockfrostprotocol-parameters

The course's Lucid lessons build transactions on Blockfrost, which supplies the protocol parameters.

• code/Week03/lucid/src/index.js:30new L.Blockfrost("https://cardano-preview.blockfrost.io/api/v0", "preview1JXEDVldkIyBkxEUrEx3n9ll4afFK1Xj"),

kupoblock-encodingera-identitytransaction-encoding

The Kupo-wrapped chain context reads UTxOs, datums and scripts from Kupo. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• pycardano/backend/kupo.py:156kupo_utxo_url = self._kupo_url + "/matches/" + address + "?unspent"

ogmiosprotocol-parameterstransaction-encodingera-identityplutus-language

The Ogmios v5 and v6 chain contexts read parameters, submit and evaluate through Ogmios.

• pycardano/backend/ogmios_v6.py:144def protocol_param(self) -> ProtocolParameters:
• pycardano/backend/ogmios_v6.py:337def submit_tx_cbor(self, cbor: Union[bytes, str]):
• pycardano/backend/ogmios_v5.py:389def evaluate_tx_cbor(self, cbor: Union[bytes, str]) -> Dict[str, ExecutionUnits]:

blockfrostprotocol-parameters

The Blockfrost chain context reads latest epoch parameters.

• pycardano/backend/blockfrost.py:133params = self.api.epoch_latest_parameters()

kupoblock-encodingera-identitytransaction-encoding

The Kupo provider reads UTxOs from Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• kupo.go:110url = fmt.Sprintf("%s/matches/%s?unspent&resolve_hashes", kp.baseUrl, address)

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

rum's Maestro provider submits transactions through Maestro's transaction manager.

• maestro.go:24txHash, err := ms.maestroClient.TxManagerSubmit(txCbor)

cardano-apicardano-api-haskellera-identitytransaction-encoding

Coin selection and submission are fixed to the Conway era on cardano-api ==11.0.0.0.

• src/coin-selection/lib/Convex/CoinSelection.hs:165type ERA = ConwayEra
• src/coin-selection/lib/Convex/Query.hs:138mapError SubmitError (sendTx finalTx) $> finalTx

blockfrostera-identityprotocol-parameters

The Blockfrost backend reads /network/eras for era history and converts Blockfrost parameters as Conway parameters.

• src/blockfrost/lib/Convex/Blockfrost/MonadBlockchain.hs:239networkEras <- Client.getNetworkEras
• src/blockfrost/lib/Convex/Blockfrost/MonadBlockchain.hs:265LedgerProtocolParameters . Types.protocolParametersConway <$> Client.g

blockfrostera-identityprotocol-parameters

The Blockfrost provider reads /network/eras and latest epoch parameters.

• scalus-cardano-ledger/shared/src/main/scala/scalus/cardano/node/BlockfrostProvider.scala:499def fetchNetworkEras: Future[Seq[EraInfo]] =
• scalus-cardano-ledger/shared/src/main/scala/scalus/cardano/node/BlockfrostProvider.scala:575fetchProtocolParamsFromUrl(s"$baseUrl/epochs/latest/parameters")

bloxbean-cardano-client-librarytransaction-encodingplutus-language

The Scalus evaluator for cardano-client-lib evaluates transactions in cardano-client-lib's model, which has no V4 language or Dijkstra body keys.

• bloxbean-cardano-client-lib/src/main/scala/scalus/bloxbean/ScalusTransactionEvaluator.scala:36class ScalusTransactionEvaluator(

pallasnode-to-client-protocol

The n2c source connects through Pallas 0.30.1, which predates V23; last pushed 2025-01.

• Cargo.toml:15pallas = "0.30.1"
• src/sources/n2c.rs:9use pallas::network::facades::NodeClient;

ogmiosblock-encodingera-identitytransaction-encoding

The Ogmios source follows the chain through Ogmios chain-sync; last pushed 2025-01.

• src/sources/ogmios.rs:58OgmiosResponse::RollForward(rf) => {

pallasblock-encodingera-identity

Both chain sources decode node blocks and headers through Pallas 0.30.1, which has no Dijkstra era.

• src/sources/n2c.rs:95let block = MultiEraBlock::decode(cbor).or_panic()?;
• src/sources/n2n.rs:41MultiEraHeader::decode(header.variant, Some(subtag), &header.cbor)
• Cargo.toml:15pallas = "0.30.1"

own codeera-identity

The era read from the node (dijkstra after the fork) selects the min-UTxO calculation by name; only babbage and conway get the map-based output encoding, so a Dijkstra-era output is sized with the pre-Babbage array format and the computed minimum is wrong.

• cardano/mainnet/00_common.sh:652"online") local tmpEra=$(${cardanocli} latest query tip ${magicparam}
• cardano/mainnet/00_common.sh:663nodeEraParam="--${tmpEra}-era";
• cardano/mainnet/00_common.sh:1307*"babbage"* | *"conway"* ) #Build the tx-out cbor in babbage-tx format with maps
• cardano/mainnet/00_common.sh:1316* ) #Build the tx-out cbor in alonzo/shelley format with array

own codeprotocol-parameters

Vote tallies assign each changed parameter to a governance group by name; the 23 Dijkstra parameters match no group, so a proposal changing only those leaves the threshold at zero and the script exits with an error.

• cardano/mainnet/24a_genVote.sh:810*"poolPledgeInfluence"*|*"poolRetireMaxEpoch"*|*"stakePoolTargetNum"*|*"costModels"*|*"collateralPercentage"*)
• cardano/mainnet/24a_genVote.sh:824if [[ "${dRepPowerThreshold}" == "0" || "${dRepPowerThreshold}" == "" ]]; then echo -e "\e[35mERROR - Something went wrong finding the dRepPowerThreshold.

blockfrostprotocol-parameters

The CLI builds transactions with Blaze on its Blockfrost provider, which reads Blockfrost epoch parameters.

• packages/cli/src/utils.ts:89return new Blockfrost({

kupoblock-encodingera-identitytransaction-encoding

The Kupogmios provider reads UTxOs from Kupo matches. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• lib/sutra/provider/kupogmios/client.ex:100Req.get!(clients.kupo, url: "matches/#{pattern}").body

ogmiosprotocol-parameterstransaction-encodingera-identity

The Kupogmios provider reads protocol parameters and submits transactions through Ogmios.

• lib/sutra/provider/kupogmios/client.ex:34params = %{"jsonrpc" => "2.0", "method" => "queryLedgerState/protocolParameters"}
• lib/sutra/provider/kupogmios/client.ex:75method: "submitTransaction",

blockfrostprotocol-parameters

The Blockfrost provider reads /epochs/latest/parameters.

• lib/sutra/provider/blockfrost/client.ex:89Req.get!(client, url: "epochs/latest/parameters").body

koiosprotocol-parameters

The Koios provider reads /epoch_params.

• lib/sutra/provider/koios/client.ex:84Req.get!(client, url: "epoch_params", params: %{"_epoch_no" => curr_epoch_no})

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

Sutra's Maestro provider reads protocol parameters and submits transactions through Maestro.

• lib/sutra/provider/maestro/client.ex:77Req.get!(client, url: "protocol-parameters").body["data"]
• lib/sutra/provider/maestro/client.ex:84url: "txmanager",

aikenplutus-languageplutus-script-context

Script evaluation calls Aiken's uplc eval_phase_two_raw, which neither evaluates PlutusV4 nor builds its context.

• native/sutra_uplc/Cargo.toml:14uplc = "1.1.19"
• native/sutra_uplc/src/lib.rs:3use uplc::tx::{apply_params_to_script, eval_phase_two_raw};

gouroborosera-identity

Decodes every mempool transaction through gouroboros ledger types that predate the Dijkstra transaction format.

• main.go:1258txType, err := ledger.DetermineTransactionType(raw)
• main.go:1262ltx, err := ledger.NewTransactionFromCbor(txType, raw)

blockfrostprotocol-parameters

The React hooks build transactions with Lucid on its Blockfrost provider, which supplies protocol parameters.

• src/lib/get-node-provider.ts:1import { Blockfrost } from "lucid-cardano"

cardano-serialization-lib-cslplutus-language

Transaction utilities decode supplied transactions with CSL.

• packages/whisky-csl/src/utils/transaction.rs:12let csl_tx = csl::FixedTransaction::from_hex(tx_hex).map_err(WError::from_err(

blockfrostprotocol-parameters

The Blockfrost fetcher reads epoch parameters for transaction building.

• packages/whisky-provider/src/blockfrost/fetcher.rs:215let url = format!("/epochs/{}/parameters", append_epoch_string);

cquisitor-libera-identityplutus-languagetransaction-encoding

The transaction validator runs cquisitor-lib over transactions it is given.

• packages/whisky-csl/src/utils/validator.rs:3use cquisitor_lib::validators::validation_result::ValidationResult;

maestro (deprecated)era-identityprotocol-parameterstransaction-encoding

whisky-provider exports a Maestro fetcher, evaluator and submitter; on a deprecated provider every one of them needs replacing.

• packages/whisky-provider/src/lib.rs:4pub use maestro::MaestroProvider;
• packages/whisky-provider/src/maestro/submitter.rs:9let url = "/txmanager";

aikenplutus-languageplutus-script-context

The evaluator runs transaction scripts with Aiken's uplc 1.1.10, which neither evaluates PlutusV4 nor builds its context.

• packages/Cargo.toml:18uplc = "=1.1.10"
• packages/whisky-csl/src/utils/evaluator.rs:17use uplc::{tx::error::Error as UplcError, tx::ResolvedInput, Hash, TransactionInput};
• packages/whisky-csl/src/utils/evaluator.rs:63eval_phase_two(

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

Transaction utilities decode supplied transactions with CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key.

• packages/whisky-csl/src/utils/transaction.rs:12let csl_tx = csl::FixedTransaction::from_hex(tx_hex).map_err(WError::from_err(

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

Xogmios is an Elixir Ogmios client: chain-sync, submission, evaluation and state queries.

• lib/xogmios.ex:8defmodule ChainSyncClient do
• lib/xogmios/tx_submission/messages.ex:15"method": "submitTransaction",

bloxbean-cardano-client-libraryera-identity

Era detection maps onto cardano-client-lib's Era enum, which ends at Conway.

• core/src/main/java/com/bloxbean/cardano/yaci/core/common/EraUtil.java:34return Era.Conway;

ogmiosblock-encodingera-identityplutus-languageprotocol-parameterstransaction-encoding

The devkit downloads and runs Ogmios as part of its local cluster, so a Dijkstra devnet inherits Ogmios's gap.

• applications/cli/src/main/java/com/bloxbean/cardano/yacicli/commands/common/DownloadService.java:35private final static String OGMIOS_DOWNLOAD_URL = "https://github.com/CardanoSolutions/ogmios/releases/download";

kupoblock-encodingera-identitytransaction-encoding

The devkit downloads and runs Kupo as part of its local cluster. Kupo cannot index Dijkstra blocks (R2 gap), so its matches stop at the fork.

• applications/cli/src/main/java/com/bloxbean/cardano/yacicli/commands/common/DownloadService.java:36private final static String KUPO_DOWNLOAD_URL = "https://github.com/CardanoSolutions/kupo/releases/download";

scalusplutus-script-contexttransaction-encoding

The submit component evaluates scripts with Scalus.

• components/submit/src/main/java/com/bloxbean/cardano/yaci/store/submit/service/scalus/ScalusTxEvaluationService.java:22import scalus.bloxbean.ScalusTransactionEvaluator;

ogmiostransaction-encodingera-identity

When an Ogmios URL is configured, the submit component relays transactions through Ogmios.

• components/submit/src/main/java/com/bloxbean/cardano/yaci/store/submit/service/OgmiosService.java:41this.ogmiosBackendService = new OgmiosBackendService(ogmiosUrl);

bloxbean-cardano-client-libraryera-identity

Era-dependent processing uses cardano-client-lib's Era enum, which ends at Conway.

• aggregates/account/src/main/java/com/bloxbean/cardano/yaci/store/account/processor/AccountBalanceProcessor.java:154if (event.getMetadata().getEra().getValue() < Era.Conway.getValue()) {

scalusplutus-script-contexttransaction-encoding

Yano evaluates scripts with Scalus, which does not implement PlutusV4 evaluation or context building.

• scalus-bridge/src/main/java/org/yanoproject/scalusbridge/ScalusBasedTransactionEvaluator.java:12import scalus.bloxbean.ScalusTransactionEvaluator;

cardano-serialization-lib-cslplutus-language

Transaction review decodes dApp-supplied transactions with CSL before signing.

• mobile/src/features/ReviewTx/common/hooks/useTxBody.tsx:21const tx = csl.Transaction.fromHex(cbor)

koiosprotocol-parameters

The airdrop escrow fetches the PlutusV3 cost model from Koios /epoch_params.

• mobile/src/features/Airdrop/common/escrow/costModels.ts:14'https://api.koios.rest/api/v1/epoch_params?limit=1',

ledgerjs-hw-app-cardanotransaction-encoding

Signs transactions built elsewhere (dApp requests or transaction files) on a Ledger for CIP-30 dApp requests.

• mobile/packages/cardano-wallet/cip30/cip30-ledger.ts:13} from '@cardano-foundation/ledgerjs-hw-app-cardano'

cardano-serialization-lib-cslprotocol-parametersstake-pool-registrationtransaction-encoding

Transaction review decodes dApp-supplied transactions with CSL, whose body decoder rejects keys beyond 22, parameter updates beyond key 33 and pool certificates with a BLS key.

• mobile/src/features/ReviewTx/common/hooks/useTxBody.tsx:21const tx = csl.Transaction.fromHex(cbor)

blockfrostprotocol-parameters

The CLI reads Blockfrost's latest epoch parameters.

• cli/src/cardano.rs:91.epochs_latest_parameters()