ledger

type AllegraBlock struct {
	Header                 ShelleyBlockHeader
	TransactionBodies      []AllegraTransactionBody
	TransactionWitnessSets []ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	TransactionMetadataSet map[uint]cbor.RawMessage
	// contains filtered or unexported fields
}

type AllegraTransaction struct {
	Body       AllegraTransactionBody
	WitnessSet ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	Metadata cbor.RawMessage
	// contains filtered or unexported fields
}

type AllegraTransactionBody struct {
	ShelleyTransactionBody
	ValidityIntervalStart uint64 `cbor:"8,keyasint,omitempty"`
}

type AlonzoBlock struct {
	Header                 ShelleyBlockHeader
	TransactionBodies      []AlonzoTransactionBody
	TransactionWitnessSets []AlonzoTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	TransactionMetadataSet map[uint]cbor.RawMessage
	InvalidTransactions    []uint
	// contains filtered or unexported fields
}

type AlonzoTransaction struct {
	Body       AlonzoTransactionBody
	WitnessSet AlonzoTransactionWitnessSet
	IsValid    bool
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	Metadata cbor.RawMessage
	// contains filtered or unexported fields
}

type AlonzoTransactionBody struct {
	MaryTransactionBody
	ScriptDataHash  Blake2b256                `cbor:"11,keyasint,omitempty"`
	Collateral      []ShelleyTransactionInput `cbor:"13,keyasint,omitempty"`
	RequiredSigners []Blake2b224              `cbor:"14,keyasint,omitempty"`
	NetworkId       uint8                     `cbor:"15,keyasint,omitempty"`
}

type AlonzoTransactionWitnessSet struct {
	ShelleyTransactionWitnessSet
	PlutusScripts interface{} `cbor:"3,keyasint,omitempty"`
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	PlutusData []cbor.RawMessage `cbor:"4,keyasint,omitempty"`
	Redeemers  []cbor.RawMessage `cbor:"5,keyasint,omitempty"`
}

type BabbageBlock struct {
	Header                 BabbageBlockHeader
	TransactionBodies      []BabbageTransactionBody
	TransactionWitnessSets []AlonzoTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	TransactionMetadataSet map[uint]cbor.RawMessage
	InvalidTransactions    []uint
	// contains filtered or unexported fields
}

type BabbageBlockHeader struct {
	Body struct {
		BlockNumber   uint64
		Slot          uint64
		PrevHash      Blake2b256
		IssuerVkey    interface{}
		VrfKey        interface{}
		VrfResult     interface{}
		BlockBodySize uint32
		BlockBodyHash Blake2b256
		OpCert        struct {
			HotVkey        interface{}
			SequenceNumber uint32
			KesPeriod      uint32
			Signature      interface{}
			// contains filtered or unexported fields
		}
		ProtoVersion struct {
			Major uint64
			Minor uint64
			// contains filtered or unexported fields
		}
		// contains filtered or unexported fields
	}
	Signature interface{}
	// contains filtered or unexported fields
}

type BabbageTransaction struct {
	Body       BabbageTransactionBody
	WitnessSet AlonzoTransactionWitnessSet
	IsValid    bool
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	Metadata cbor.RawMessage
	// contains filtered or unexported fields
}

type BabbageTransactionBody struct {
	AlonzoTransactionBody
	CollateralReturn ShelleyTransactionOutput  `cbor:"16,keyasint,omitempty"`
	TotalCollateral  uint64                    `cbor:"17,keyasint,omitempty"`
	ReferenceInputs  []ShelleyTransactionInput `cbor:"18,keyasint,omitempty"`
}

type Blake2b224 [28]byte

type Blake2b256 [32]byte

type ByronEpochBoundaryBlock struct {
	Header ByronEpochBoundaryBlockHeader
	Body   []Blake2b224
	Extra  []interface{}
	// contains filtered or unexported fields
}

type ByronEpochBoundaryBlockHeader struct {
	ProtocolMagic uint32
	PrevBlock     Blake2b256
	BodyProof     interface{}
	ConsensusData struct {
		Epoch      uint64
		Difficulty struct {
			Value uint64
			// contains filtered or unexported fields
		}
		// contains filtered or unexported fields
	}
	ExtraData interface{}
	// contains filtered or unexported fields
}

type ByronMainBlock struct {
	Header ByronMainBlockHeader
	Body   ByronMainBlockBody
	Extra  []interface{}
	// contains filtered or unexported fields
}

type ByronMainBlockBody struct {
	TxPayload []ByronTransactionBody
	// We keep this field as raw CBOR, since it contains a map with []byte
	// keys, which Go doesn't allow
	SscPayload cbor.RawMessage
	DlgPayload []interface{}
	UpdPayload []interface{}
	// contains filtered or unexported fields
}

type ByronMainBlockHeader struct {
	ProtocolMagic uint32
	PrevBlock     Blake2b256
	BodyProof     interface{}
	ConsensusData struct {

		// [slotid, pubkey, difficulty, blocksig]
		SlotId struct {
			Epoch uint64
			Slot  uint16
			// contains filtered or unexported fields
		}
		PubKey     []byte
		Difficulty struct {
			Unknown uint64
			// contains filtered or unexported fields
		}
		BlockSig []interface{}
		// contains filtered or unexported fields
	}
	ExtraData struct {
		BlockVersion struct {
			Major   uint16
			Minor   uint16
			Unknown uint8
			// contains filtered or unexported fields
		}
		SoftwareVersion struct {
			Name    string
			Unknown uint32
			// contains filtered or unexported fields
		}
		Attributes interface{}
		ExtraProof Blake2b256
		// contains filtered or unexported fields
	}
	// contains filtered or unexported fields
}

type ByronTransaction interface{}

type ByronTransactionBody interface{}

type MaryBlock struct {
	Header                 ShelleyBlockHeader
	TransactionBodies      []MaryTransactionBody
	TransactionWitnessSets []ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	TransactionMetadataSet map[uint]cbor.RawMessage
	// contains filtered or unexported fields
}

type MaryTransaction struct {
	Body       MaryTransactionBody
	WitnessSet ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	Metadata cbor.RawMessage
	// contains filtered or unexported fields
}

type MaryTransactionBody struct {
	AllegraTransactionBody
	//Outputs []MaryTransactionOutput `cbor:"1,keyasint,omitempty"`
	Outputs []cbor.RawMessage `cbor:"1,keyasint,omitempty"`
	// TODO: further parsing of this field
	Mint cbor.RawMessage `cbor:"9,keyasint,omitempty"`
}

type MaryTransactionOutput cbor.RawMessage

type ShelleyBlock struct {
	Header                 ShelleyBlockHeader
	TransactionBodies      []ShelleyTransactionBody
	TransactionWitnessSets []ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	TransactionMetadataSet map[uint]cbor.RawMessage
	// contains filtered or unexported fields
}

type ShelleyBlockHeader struct {
	Body struct {
		BlockNumber          uint64
		Slot                 uint64
		PrevHash             Blake2b256
		IssuerVkey           interface{}
		VrfKey               interface{}
		NonceVrf             interface{}
		LeaderVrf            interface{}
		BlockBodySize        uint32
		BlockBodyHash        Blake2b256
		OpCertHotVkey        interface{}
		OpCertSequenceNumber uint32
		OpCertKesPeriod      uint32
		OpCertSignature      interface{}
		ProtoMajorVersion    uint64
		ProtoMinorVersion    uint64
		// contains filtered or unexported fields
	}
	Signature interface{}
	// contains filtered or unexported fields
}

type ShelleyTransaction struct {
	Body       ShelleyTransactionBody
	WitnessSet ShelleyTransactionWitnessSet
	// TODO: figure out how to parse properly
	// We use RawMessage here because the content is arbitrary and can contain data that
	// cannot easily be represented in Go (such as maps with bytestring keys)
	Metadata cbor.RawMessage
	// contains filtered or unexported fields
}

type ShelleyTransactionBody struct {
	Inputs  []ShelleyTransactionInput  `cbor:"0,keyasint,omitempty"`
	Outputs []ShelleyTransactionOutput `cbor:"1,keyasint,omitempty"`
	Fee     uint64                     `cbor:"2,keyasint,omitempty"`
	Ttl     uint64                     `cbor:"3,keyasint,omitempty"`
	// TODO: figure out how to parse properly
	Certificates []cbor.RawMessage `cbor:"4,keyasint,omitempty"`
	// TODO: figure out how to parse this correctly
	// We keep the raw CBOR because it can contain a map with []byte keys, which
	// Go does not allow
	Withdrawals cbor.RawMessage `cbor:"5,keyasint,omitempty"`
	Update      struct {

		// TODO: figure out how to parse properly
		// We use RawMessage here because the content is arbitrary and can contain data that
		// cannot easily be represented in Go (such as maps with bytestring keys)
		ProtocolParamUpdates cbor.RawMessage
		Epoch                uint64
		// contains filtered or unexported fields
	} `cbor:"6,keyasint,omitempty"`
	MetadataHash Blake2b256 `cbor:"7,keyasint,omitempty"`
}

type ShelleyTransactionInput struct {
	Id    Blake2b256
	Index uint32
	// contains filtered or unexported fields
}

type ShelleyTransactionOutput struct {
	Address Blake2b256
	Amount  uint64
	// contains filtered or unexported fields
}

type ShelleyTransactionWitnessSet struct {
	VkeyWitnesses      []interface{} `cbor:"0,keyasint,omitempty"`
	MultisigScripts    []interface{} `cbor:"1,keyasint,omitempty"`
	BootstrapWitnesses []interface{} `cbor:"2,keyasint,omitempty"`
}