feat/runtime: Add few parachain runtime calls

lib/runtime/constants.go

@@ -20,6 +20,12 @@ const (
 	WESTEND_RUNTIME_V0929_FP  = "westend_runtime-v929.compact.wasm"
 	WESTEND_RUNTIME_V0929_URL = "https://github.com/paritytech/polkadot/releases/download/v0.9." +
 		"29/westend_runtime-v9290.compact.compressed.wasm?raw=true"
+
+	// v0.9.42 westend
+	WESTEND_RUNTIME_v0942     = "westend_runtime-v942"
+	WESTEND_RUNTIME_V0942_FP  = "westend_runtime-v942.compact.wasm"
+	WESTEND_RUNTIME_V0942_URL = "https://github.com/paritytech/polkadot/releases/download/v0.9." +
+		"42/westend_runtime-v9420.compact.compressed.wasm?raw=true"
 )
 
 const (
@@ -60,4 +66,20 @@ const (
 	TransactionPaymentCallAPIQueryCallInfo = "TransactionPaymentCallApi_query_call_info"
 	// TransactionPaymentCallAPIQueryCallFeeDetails returns call query call fee details
 	TransactionPaymentCallAPIQueryCallFeeDetails = "TransactionPaymentCallApi_query_call_fee_details"
+	// ParachainHostValidators is the runtime API call ParachainHost_validators
+	ParachainHostValidators = "ParachainHost_validators"
+	// ParachainHostValidatorGroups is the runtime API call ParachainHost_validator_groups
+	ParachainHostValidatorGroups = "ParachainHost_validator_groups"
+	// ParachainHostAvailabilityCores is the runtime API call ParachainHost_availability_cores
+	ParachainHostAvailabilityCores = "ParachainHost_availability_cores"
+	// ParachainHostCheckValidationOutputs is the runtime API call ParachainHost_check_validation_outputs
+	ParachainHostCheckValidationOutputs = "ParachainHost_check_validation_outputs"
+	// ParachainHostSessionIndexForChild is the runtime API call ParachainHost_session_index_for_child
+	ParachainHostSessionIndexForChild = "ParachainHost_session_index_for_child"
+	// ParachainHostCandidatePendingAvailability is the runtime API call ParachainHost_candidate_pending_availability
+	ParachainHostCandidatePendingAvailability = "ParachainHost_candidate_pending_availability"
+	// ParachainHostCandidateEvents is the runtime API call ParachainHost_candidate_events
+	ParachainHostCandidateEvents = "ParachainHost_candidate_events"
+	// ParachainHostSessionInfo is the runtime API call ParachainHost_session_info
+	ParachainHostSessionInfo = "ParachainHost_session_info"
 )

lib/runtime/test_helpers.go

@@ -81,6 +81,9 @@ func GetRuntime(ctx context.Context, runtime string) (
 	case WESTEND_RUNTIME_v0929:
 		runtimeFilename = WESTEND_RUNTIME_V0929_FP
 		url = WESTEND_RUNTIME_V0929_URL
+	case WESTEND_RUNTIME_v0942:
+		runtimeFilename = WESTEND_RUNTIME_V0942_FP
+		url = WESTEND_RUNTIME_V0942_URL
 	default:
 		return "", fmt.Errorf("%w: %s", ErrRuntimeUnknown, runtime)
 	}

lib/runtime/wasmer/exports.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/ChainSafe/gossamer/dot/types"
 	"github.com/ChainSafe/gossamer/lib/crypto/ed25519"
+	"github.com/ChainSafe/gossamer/lib/parachain"
 	"github.com/ChainSafe/gossamer/lib/runtime"
 	"github.com/ChainSafe/gossamer/lib/transaction"
 	"github.com/ChainSafe/gossamer/pkg/scale"
@@ -346,6 +347,174 @@ func (in *Instance) GrandpaSubmitReportEquivocationUnsignedExtrinsic(
 	return nil
 }
 
+// ParachainHostValidators returns the validator set at the current state.
+// The specified validators are responsible for backing parachains for the current state.
+func (in *Instance) ParachainHostValidators() ([]parachain.ValidatorID, error) {
+	encodedValidators, err := in.Exec(runtime.ParachainHostValidators, []byte{})
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	var validatorIDs []parachain.ValidatorID
+	err = scale.Unmarshal(encodedValidators, &validatorIDs)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return validatorIDs, nil
+}
+
+// ParachainHostValidatorGroups returns the validator groups used during the current session.
+// The validators in the groups are referred to by the validator set Id.
+func (in *Instance) ParachainHostValidatorGroups() (*parachain.ValidatorGroups, error) {
+	encodedValidatorGroups, err := in.Exec(runtime.ParachainHostValidatorGroups, []byte{})
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	var validatorGroups parachain.ValidatorGroups
+	err = scale.Unmarshal(encodedValidatorGroups, &validatorGroups)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return &validatorGroups, nil
+}
+
+// ParachainHostAvailabilityCores returns the availability cores for the current state.
+func (in *Instance) ParachainHostAvailabilityCores() (*scale.VaryingDataTypeSlice, error) {
+	encodedAvailabilityCores, err := in.Exec(runtime.ParachainHostAvailabilityCores, []byte{})
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	availabilityCores, err := parachain.NewAvailabilityCores()
+	if err != nil {
+		return nil, fmt.Errorf("new availability cores: %w", err)
+	}
+	err = scale.Unmarshal(encodedAvailabilityCores, &availabilityCores)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return &availabilityCores, nil
+}
+
+// ParachainHostCheckValidationOutputs checks the validation outputs of a candidate.
+// Returns true if the candidate is valid.
+func (in *Instance) ParachainHostCheckValidationOutputs(
+	parachainID parachain.ParaID,
+	outputs parachain.CandidateCommitments,
+) (bool, error) {
+	buffer := bytes.NewBuffer(nil)
+	encoder := scale.NewEncoder(buffer)
+	err := encoder.Encode(parachainID)
+	if err != nil {
+		return false, fmt.Errorf("encode parachainID: %w", err)
+	}
+	err = encoder.Encode(outputs)
+	if err != nil {
+		return false, fmt.Errorf("encode outputs: %w", err)
+	}
+
+	encodedPersistedValidationData, err := in.Exec(runtime.ParachainHostCheckValidationOutputs, buffer.Bytes())
+	if err != nil {
+		return false, fmt.Errorf("exec: %w", err)
+	}
+
+	var isValid bool
+	err = scale.Unmarshal(encodedPersistedValidationData, &isValid)
+	if err != nil {
+		return false, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return isValid, nil
+}
+
+// ParachainHostSessionIndexForChild returns the session index that is expected at the child of a block.
+func (in *Instance) ParachainHostSessionIndexForChild() (parachain.SessionIndex, error) {
+	encodedSessionIndex, err := in.Exec(runtime.ParachainHostSessionIndexForChild, []byte{})
+	if err != nil {
+		return 0, fmt.Errorf("exec: %w", err)
+	}
+
+	var sessionIndex parachain.SessionIndex
+	err = scale.Unmarshal(encodedSessionIndex, &sessionIndex)
+	if err != nil {
+		return 0, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return sessionIndex, nil
+}
+
+// ParachainHostCandidatePendingAvailability returns the receipt of a candidate pending availability
+// for any parachain assigned to an occupied availability core.
+func (in *Instance) ParachainHostCandidatePendingAvailability(
+	parachainID parachain.ParaID,
+) (*parachain.CommittedCandidateReceipt, error) {
+	buffer := bytes.NewBuffer(nil)
+	encoder := scale.NewEncoder(buffer)
+	err := encoder.Encode(parachainID)
+	if err != nil {
+		return nil, fmt.Errorf("encode parachainID: %w", err)
+	}
+
+	encodedCandidateReceipt, err := in.Exec(runtime.ParachainHostCandidatePendingAvailability, buffer.Bytes())
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	var candidateReceipt *parachain.CommittedCandidateReceipt
+	err = scale.Unmarshal(encodedCandidateReceipt, &candidateReceipt)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return candidateReceipt, nil
+}
+
+// ParachainHostCandidateEvents returns an array of candidate events that occurred within the latest state.
+func (in *Instance) ParachainHostCandidateEvents() (*scale.VaryingDataTypeSlice, error) {
+	encodedCandidateEvents, err := in.Exec(runtime.ParachainHostCandidateEvents, []byte{})
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	candidateEvents, err := parachain.NewCandidateEvents()
+	if err != nil {
+		return nil, fmt.Errorf("create new candidate events: %w", err)
+	}
+	err = scale.Unmarshal(encodedCandidateEvents, &candidateEvents)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return &candidateEvents, nil
+}
+
+// ParachainHostSessionInfo returns the session info of the given session, if available.
+func (in *Instance) ParachainHostSessionInfo(sessionIndex parachain.SessionIndex) (*parachain.SessionInfo, error) {
+	buffer := bytes.NewBuffer(nil)
+	encoder := scale.NewEncoder(buffer)
+	err := encoder.Encode(sessionIndex)
+	if err != nil {
+		return nil, fmt.Errorf("encode sessionIndex: %w", err)
+	}
+
+	encodedSessionInfo, err := in.Exec(runtime.ParachainHostSessionInfo, buffer.Bytes())
+	if err != nil {
+		return nil, fmt.Errorf("exec: %w", err)
+	}
+
+	var sessionInfo *parachain.SessionInfo
+	err = scale.Unmarshal(encodedSessionInfo, &sessionInfo)
+	if err != nil {
+		return nil, fmt.Errorf("unmarshalling: %w", err)
+	}
+
+	return sessionInfo, nil
+}
+
 func (in *Instance) RandomSeed()          {}
 func (in *Instance) OffchainWorker()      {}
 func (in *Instance) GenerateSessionKeys() {}