constructors.gen.go

// Code generated by ride/generate/main.go. DO NOT EDIT.

package ride

import (
	"github.com/pkg/errors"
)

func assetV3Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 8); err != nil {
		return nil, errors.Wrap(err, "assetV3Constructor")
	}

	id, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for id", args_[0].instanceOf())
	}

	quantity, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for quantity", args_[1].instanceOf())
	}

	decimals, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for decimals", args_[2].instanceOf())
	}

	issuer, ok := args_[3].(rideAddress)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for issuer", args_[3].instanceOf())
	}

	issuerPublicKey, ok := args_[4].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for issuerPublicKey", args_[4].instanceOf())
	}

	reissuable, ok := args_[5].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for reissuable", args_[5].instanceOf())
	}

	scripted, ok := args_[6].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for scripted", args_[6].instanceOf())
	}

	sponsored, ok := args_[7].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("assetV3Constructor: unexpected type '%s' for sponsored", args_[7].instanceOf())
	}

	return newRideAssetV3(issuerPublicKey, id, quantity, decimals, issuer, scripted, sponsored, reissuable), nil
}

func assetV4Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "assetV4Constructor")
	}

	id, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for id", args_[0].instanceOf())
	}

	quantity, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for quantity", args_[1].instanceOf())
	}

	decimals, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for decimals", args_[2].instanceOf())
	}

	issuer, ok := args_[3].(rideAddress)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for issuer", args_[3].instanceOf())
	}

	issuerPublicKey, ok := args_[4].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for issuerPublicKey", args_[4].instanceOf())
	}

	reissuable, ok := args_[5].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for reissuable", args_[5].instanceOf())
	}

	scripted, ok := args_[6].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for scripted", args_[6].instanceOf())
	}

	var minSponsoredFee rideType
	switch v := args_[7].(type) {
	case rideInt, rideUnit:
		minSponsoredFee = v
	default:
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for minSponsoredFee", args_[7].instanceOf())
	}

	name, ok := args_[8].(rideString)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for name", args_[8].instanceOf())
	}

	description, ok := args_[9].(rideString)
	if !ok {
		return nil, errors.Errorf("assetV4Constructor: unexpected type '%s' for description", args_[9].instanceOf())
	}

	return newRideAssetV4(description, name, issuerPublicKey, id, minSponsoredFee, decimals, quantity, issuer, reissuable, scripted), nil
}

func assetPairConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "assetPairConstructor")
	}

	var amountAsset rideType
	switch v := args_[0].(type) {
	case rideUnit, rideByteVector:
		amountAsset = v
	default:
		return nil, errors.Errorf("assetPairConstructor: unexpected type '%s' for amountAsset", args_[0].instanceOf())
	}

	var priceAsset rideType
	switch v := args_[1].(type) {
	case rideUnit, rideByteVector:
		priceAsset = v
	default:
		return nil, errors.Errorf("assetPairConstructor: unexpected type '%s' for priceAsset", args_[1].instanceOf())
	}

	return newRideAssetPair(amountAsset, priceAsset), nil
}

func attachedPaymentConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "attachedPaymentConstructor")
	}

	var assetId rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		assetId = v
	default:
		return nil, errors.Errorf("attachedPaymentConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	amount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("attachedPaymentConstructor: unexpected type '%s' for amount", args_[1].instanceOf())
	}

	return newRideAttachedPayment(assetId, amount), nil
}

func balanceDetailsConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 4); err != nil {
		return nil, errors.Wrap(err, "balanceDetailsConstructor")
	}

	available, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("balanceDetailsConstructor: unexpected type '%s' for available", args_[0].instanceOf())
	}

	regular, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("balanceDetailsConstructor: unexpected type '%s' for regular", args_[1].instanceOf())
	}

	generating, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("balanceDetailsConstructor: unexpected type '%s' for generating", args_[2].instanceOf())
	}

	effective, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("balanceDetailsConstructor: unexpected type '%s' for effective", args_[3].instanceOf())
	}

	return newRideBalanceDetails(available, regular, generating, effective), nil
}

func binaryEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "binaryEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("binaryEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	value, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("binaryEntryConstructor: unexpected type '%s' for value", args_[1].instanceOf())
	}

	return newRideBinaryEntry(key, value), nil
}

func blockInfoV3Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 6); err != nil {
		return nil, errors.Wrap(err, "blockInfoV3Constructor")
	}

	timestamp, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for timestamp", args_[0].instanceOf())
	}

	height, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for height", args_[1].instanceOf())
	}

	baseTarget, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for baseTarget", args_[2].instanceOf())
	}

	generationSignature, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for generationSignature", args_[3].instanceOf())
	}

	generator, ok := args_[4].(rideAddress)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for generator", args_[4].instanceOf())
	}

	generatorPublicKey, ok := args_[5].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV3Constructor: unexpected type '%s' for generatorPublicKey", args_[5].instanceOf())
	}

	return newRideBlockInfoV3(generationSignature, generatorPublicKey, baseTarget, timestamp, height, generator), nil
}

func blockInfoV4Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 7); err != nil {
		return nil, errors.Wrap(err, "blockInfoV4Constructor")
	}

	timestamp, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for timestamp", args_[0].instanceOf())
	}

	height, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for height", args_[1].instanceOf())
	}

	baseTarget, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for baseTarget", args_[2].instanceOf())
	}

	generationSignature, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for generationSignature", args_[3].instanceOf())
	}

	generator, ok := args_[4].(rideAddress)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for generator", args_[4].instanceOf())
	}

	generatorPublicKey, ok := args_[5].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for generatorPublicKey", args_[5].instanceOf())
	}

	var vrf rideType
	switch v := args_[6].(type) {
	case rideByteVector, rideUnit:
		vrf = v
	default:
		return nil, errors.Errorf("blockInfoV4Constructor: unexpected type '%s' for vrf", args_[6].instanceOf())
	}

	return newRideBlockInfoV4(vrf, generationSignature, generatorPublicKey, baseTarget, timestamp, height, generator), nil
}

func blockInfoV7Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 8); err != nil {
		return nil, errors.Wrap(err, "blockInfoV7Constructor")
	}

	timestamp, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for timestamp", args_[0].instanceOf())
	}

	height, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for height", args_[1].instanceOf())
	}

	baseTarget, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for baseTarget", args_[2].instanceOf())
	}

	generationSignature, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for generationSignature", args_[3].instanceOf())
	}

	generator, ok := args_[4].(rideAddress)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for generator", args_[4].instanceOf())
	}

	generatorPublicKey, ok := args_[5].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for generatorPublicKey", args_[5].instanceOf())
	}

	var vrf rideType
	switch v := args_[6].(type) {
	case rideByteVector, rideUnit:
		vrf = v
	default:
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for vrf", args_[6].instanceOf())
	}

	rewards, ok := args_[7].(rideList)
	if !ok {
		return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' for rewards", args_[7].instanceOf())
	}
	// checks for list elements
	for _, el := range rewards {
		switch te := el.(type) {
		case tuple2:
			if _, ok := te.el1.(rideAddress); !ok {
				return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' of element 1 in rewards list tuple", te.el1.instanceOf())
			}
			if _, ok := te.el2.(rideInt); !ok {
				return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' of element 2 in rewards list tuple", te.el2.instanceOf())
			}
		default:
			return nil, errors.Errorf("blockInfoV7Constructor: unexpected type '%s' in rewards list", te.instanceOf())
		}
	}

	return newRideBlockInfoV7(vrf, generationSignature, generatorPublicKey, baseTarget, timestamp, height, generator, rewards), nil
}

func booleanEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "booleanEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("booleanEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	value, ok := args_[1].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("booleanEntryConstructor: unexpected type '%s' for value", args_[1].instanceOf())
	}

	return newRideBooleanEntry(key, value), nil
}

func burnConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "burnConstructor")
	}

	assetId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("burnConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	quantity, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("burnConstructor: unexpected type '%s' for quantity", args_[1].instanceOf())
	}

	return newRideBurn(assetId, quantity), nil
}

func dataEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "dataEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("dataEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	var value rideType
	switch v := args_[1].(type) {
	case rideInt, rideByteVector, rideBoolean, rideString:
		value = v
	default:
		return nil, errors.Errorf("dataEntryConstructor: unexpected type '%s' for value", args_[1].instanceOf())
	}

	return newRideDataEntry(value, key), nil
}

func deleteEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 1); err != nil {
		return nil, errors.Wrap(err, "deleteEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("deleteEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	return newRideDeleteEntry(key), nil
}

func integerEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "integerEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("integerEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	value, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("integerEntryConstructor: unexpected type '%s' for value", args_[1].instanceOf())
	}

	return newRideIntegerEntry(key, value), nil
}

func invocationV3Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 6); err != nil {
		return nil, errors.Wrap(err, "invocationV3Constructor")
	}

	var payment rideType
	switch v := args_[0].(type) {
	case rideAttachedPayment, rideUnit:
		payment = v
	default:
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for payment", args_[0].instanceOf())
	}

	caller, ok := args_[1].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for caller", args_[1].instanceOf())
	}

	callerPublicKey, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for callerPublicKey", args_[2].instanceOf())
	}

	transactionId, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for transactionId", args_[3].instanceOf())
	}

	fee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for fee", args_[4].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[5].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invocationV3Constructor: unexpected type '%s' for feeAssetId", args_[5].instanceOf())
	}

	return newRideInvocationV3(payment, callerPublicKey, feeAssetId, transactionId, caller, fee), nil
}

func invocationV4Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 6); err != nil {
		return nil, errors.Wrap(err, "invocationV4Constructor")
	}

	payments, ok := args_[0].(rideList)
	if !ok {
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for payments", args_[0].instanceOf())
	}
	// checks for list elements
	for _, el := range payments {
		switch te := el.(type) {
		case rideAttachedPayment:
		default:
			return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' in payments list", te.instanceOf())
		}
	}

	caller, ok := args_[1].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for caller", args_[1].instanceOf())
	}

	callerPublicKey, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for callerPublicKey", args_[2].instanceOf())
	}

	transactionId, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for transactionId", args_[3].instanceOf())
	}

	fee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for fee", args_[4].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[5].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invocationV4Constructor: unexpected type '%s' for feeAssetId", args_[5].instanceOf())
	}

	return newRideInvocationV4(payments, callerPublicKey, feeAssetId, transactionId, caller, fee), nil
}

func invocationV5Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 8); err != nil {
		return nil, errors.Wrap(err, "invocationV5Constructor")
	}

	payments, ok := args_[0].(rideList)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for payments", args_[0].instanceOf())
	}
	// checks for list elements
	for _, el := range payments {
		switch te := el.(type) {
		case rideAttachedPayment:
		default:
			return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' in payments list", te.instanceOf())
		}
	}

	caller, ok := args_[1].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for caller", args_[1].instanceOf())
	}

	callerPublicKey, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for callerPublicKey", args_[2].instanceOf())
	}

	transactionId, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for transactionId", args_[3].instanceOf())
	}

	fee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for fee", args_[4].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[5].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for feeAssetId", args_[5].instanceOf())
	}

	originCaller, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for originCaller", args_[6].instanceOf())
	}

	var originCallerPublicKey rideType
	switch v := args_[7].(type) {
	case rideByteVector, rideUnit:
		originCallerPublicKey = v
	default:
		return nil, errors.Errorf("invocationV5Constructor: unexpected type '%s' for originCallerPublicKey", args_[7].instanceOf())
	}

	return newRideInvocationV5(originCaller, payments, callerPublicKey, feeAssetId, originCallerPublicKey, transactionId, caller, fee), nil
}

func issueConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 7); err != nil {
		return nil, errors.Wrap(err, "issueConstructor")
	}

	name, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for name", args_[0].instanceOf())
	}

	description, ok := args_[1].(rideString)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for description", args_[1].instanceOf())
	}

	quantity, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for quantity", args_[2].instanceOf())
	}

	decimals, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for decimals", args_[3].instanceOf())
	}

	isReissuable, ok := args_[4].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for isReissuable", args_[4].instanceOf())
	}

	var compiledScript rideType
	switch v := args_[5].(type) {
	case rideByteVector, rideUnit:
		compiledScript = v
	default:
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for compiledScript", args_[5].instanceOf())
	}

	nonce, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueConstructor: unexpected type '%s' for nonce", args_[6].instanceOf())
	}

	return newRideIssue(compiledScript, name, description, nonce, decimals, quantity, isReissuable), nil
}

func leaseCancelConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 1); err != nil {
		return nil, errors.Wrap(err, "leaseCancelConstructor")
	}

	leaseId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseCancelConstructor: unexpected type '%s' for leaseId", args_[0].instanceOf())
	}

	return newRideLeaseCancel(leaseId), nil
}

func leaseConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 3); err != nil {
		return nil, errors.Wrap(err, "leaseConstructor")
	}

	var recipient rideType
	switch v := args_[0].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("leaseConstructor: unexpected type '%s' for recipient", args_[0].instanceOf())
	}

	amount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseConstructor: unexpected type '%s' for amount", args_[1].instanceOf())
	}

	nonce, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseConstructor: unexpected type '%s' for nonce", args_[2].instanceOf())
	}

	return newRideLease(recipient, amount, nonce), nil
}

func orderConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 14); err != nil {
		return nil, errors.Wrap(err, "orderConstructor")
	}

	id, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for id", args_[0].instanceOf())
	}

	matcherPublicKey, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for matcherPublicKey", args_[1].instanceOf())
	}

	assetPair, ok := args_[2].(rideType)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for assetPair", args_[2].instanceOf())
	}

	orderType, ok := args_[3].(rideType)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for orderType", args_[3].instanceOf())
	}

	price, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for price", args_[4].instanceOf())
	}

	amount, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for amount", args_[5].instanceOf())
	}

	timestamp, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for timestamp", args_[6].instanceOf())
	}

	expiration, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for expiration", args_[7].instanceOf())
	}

	matcherFee, ok := args_[8].(rideInt)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for matcherFee", args_[8].instanceOf())
	}

	var matcherFeeAssetId rideType
	switch v := args_[9].(type) {
	case rideByteVector, rideUnit:
		matcherFeeAssetId = v
	default:
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for matcherFeeAssetId", args_[9].instanceOf())
	}

	sender, ok := args_[10].(rideAddress)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for sender", args_[10].instanceOf())
	}

	senderPublicKey, ok := args_[11].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for senderPublicKey", args_[11].instanceOf())
	}

	bodyBytes, ok := args_[12].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for bodyBytes", args_[12].instanceOf())
	}

	proofs, ok := args_[13].(rideList)
	if !ok {
		return nil, errors.Errorf("orderConstructor: unexpected type '%s' for proofs", args_[13].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("orderConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideOrder(assetPair, orderType, matcherFeeAssetId, proofs, bodyBytes, id, senderPublicKey, matcherPublicKey, amount, timestamp, expiration, matcherFee, price, sender), nil
}

func reissueConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 3); err != nil {
		return nil, errors.Wrap(err, "reissueConstructor")
	}

	assetId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("reissueConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	quantity, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("reissueConstructor: unexpected type '%s' for quantity", args_[1].instanceOf())
	}

	isReissuable, ok := args_[2].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("reissueConstructor: unexpected type '%s' for isReissuable", args_[2].instanceOf())
	}

	return newRideReissue(assetId, quantity, isReissuable), nil
}

func scriptResultConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "scriptResultConstructor")
	}

	writeSet, ok := args_[0].(rideWriteSet)
	if !ok {
		return nil, errors.Errorf("scriptResultConstructor: unexpected type '%s' for writeSet", args_[0].instanceOf())
	}

	transferSet, ok := args_[1].(rideTransferSet)
	if !ok {
		return nil, errors.Errorf("scriptResultConstructor: unexpected type '%s' for transferSet", args_[1].instanceOf())
	}

	return newRideScriptResult(writeSet, transferSet), nil
}

func scriptTransferConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 3); err != nil {
		return nil, errors.Wrap(err, "scriptTransferConstructor")
	}

	var recipient rideType
	switch v := args_[0].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("scriptTransferConstructor: unexpected type '%s' for recipient", args_[0].instanceOf())
	}

	amount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("scriptTransferConstructor: unexpected type '%s' for amount", args_[1].instanceOf())
	}

	var asset rideType
	switch v := args_[2].(type) {
	case rideByteVector, rideUnit:
		asset = v
	default:
		return nil, errors.Errorf("scriptTransferConstructor: unexpected type '%s' for asset", args_[2].instanceOf())
	}

	return newRideScriptTransfer(asset, recipient, amount), nil
}

func sponsorFeeConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "sponsorFeeConstructor")
	}

	assetId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("sponsorFeeConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	minSponsoredAssetFee, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("sponsorFeeConstructor: unexpected type '%s' for minSponsoredAssetFee", args_[1].instanceOf())
	}

	return newRideSponsorFee(assetId, minSponsoredAssetFee), nil
}

func stringEntryConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "stringEntryConstructor")
	}

	key, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("stringEntryConstructor: unexpected type '%s' for key", args_[0].instanceOf())
	}

	value, ok := args_[1].(rideString)
	if !ok {
		return nil, errors.Errorf("stringEntryConstructor: unexpected type '%s' for value", args_[1].instanceOf())
	}

	return newRideStringEntry(key, value), nil
}

func transferConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 2); err != nil {
		return nil, errors.Wrap(err, "transferConstructor")
	}

	var recipient rideType
	switch v := args_[0].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("transferConstructor: unexpected type '%s' for recipient", args_[0].instanceOf())
	}

	amount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("transferConstructor: unexpected type '%s' for amount", args_[1].instanceOf())
	}

	return newRideTransfer(recipient, amount), nil
}

func transferSetConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 1); err != nil {
		return nil, errors.Wrap(err, "transferSetConstructor")
	}

	transfers, ok := args_[0].(rideList)
	if !ok {
		return nil, errors.Errorf("transferSetConstructor: unexpected type '%s' for transfers", args_[0].instanceOf())
	}
	// checks for list elements
	for _, el := range transfers {
		switch te := el.(type) {
		case rideScriptTransfer:
		default:
			return nil, errors.Errorf("transferSetConstructor: unexpected type '%s' in transfers list", te.instanceOf())
		}
	}

	return newRideTransferSet(transfers), nil
}

func writeSetConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 1); err != nil {
		return nil, errors.Wrap(err, "writeSetConstructor")
	}

	data, ok := args_[0].(rideList)
	if !ok {
		return nil, errors.Errorf("writeSetConstructor: unexpected type '%s' for data", args_[0].instanceOf())
	}
	// checks for list elements
	for _, el := range data {
		switch te := el.(type) {
		case rideDataEntry:
		default:
			return nil, errors.Errorf("writeSetConstructor: unexpected type '%s' in data list", te.instanceOf())
		}
	}

	return newRideWriteSet(data), nil
}

func burnTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "burnTransactionConstructor")
	}

	quantity, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for quantity", args_[0].instanceOf())
	}

	assetId, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for assetId", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("burnTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideBurnTransaction(bodyBytes, proofs, senderPublicKey, assetId, id, timestamp, version, quantity, fee, sender), nil
}

func createAliasTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 9); err != nil {
		return nil, errors.Wrap(err, "createAliasTransactionConstructor")
	}

	alias, ok := args_[0].(rideString)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for alias", args_[0].instanceOf())
	}

	id, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for id", args_[1].instanceOf())
	}

	fee, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for fee", args_[2].instanceOf())
	}

	timestamp, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for timestamp", args_[3].instanceOf())
	}

	version, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for version", args_[4].instanceOf())
	}

	sender, ok := args_[5].(rideAddress)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for sender", args_[5].instanceOf())
	}

	senderPublicKey, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[6].instanceOf())
	}

	bodyBytes, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for bodyBytes", args_[7].instanceOf())
	}

	proofs, ok := args_[8].(rideList)
	if !ok {
		return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' for proofs", args_[8].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("createAliasTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideCreateAliasTransaction(proofs, alias, bodyBytes, id, senderPublicKey, timestamp, fee, version, sender), nil
}

func dataTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 9); err != nil {
		return nil, errors.Wrap(err, "dataTransactionConstructor")
	}

	data, ok := args_[0].(rideList)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for data", args_[0].instanceOf())
	}
	// checks for list elements
	for _, el := range data {
		switch te := el.(type) {
		case rideBinaryEntry, rideBooleanEntry, rideDeleteEntry, rideIntegerEntry, rideStringEntry:
		default:
			return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' in data list", te.instanceOf())
		}
	}

	id, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for id", args_[1].instanceOf())
	}

	fee, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for fee", args_[2].instanceOf())
	}

	timestamp, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for timestamp", args_[3].instanceOf())
	}

	version, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for version", args_[4].instanceOf())
	}

	sender, ok := args_[5].(rideAddress)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for sender", args_[5].instanceOf())
	}

	senderPublicKey, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[6].instanceOf())
	}

	bodyBytes, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for bodyBytes", args_[7].instanceOf())
	}

	proofs, ok := args_[8].(rideList)
	if !ok {
		return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' for proofs", args_[8].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("dataTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideDataTransaction(proofs, bodyBytes, id, senderPublicKey, data, timestamp, version, fee, sender), nil
}

func exchangeTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 14); err != nil {
		return nil, errors.Wrap(err, "exchangeTransactionConstructor")
	}

	buyOrder, ok := args_[0].(rideType)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for buyOrder", args_[0].instanceOf())
	}

	sellOrder, ok := args_[1].(rideType)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for sellOrder", args_[1].instanceOf())
	}

	price, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for price", args_[2].instanceOf())
	}

	amount, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for amount", args_[3].instanceOf())
	}

	buyMatcherFee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for buyMatcherFee", args_[4].instanceOf())
	}

	sellMatcherFee, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for sellMatcherFee", args_[5].instanceOf())
	}

	id, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for id", args_[6].instanceOf())
	}

	fee, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for fee", args_[7].instanceOf())
	}

	timestamp, ok := args_[8].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for timestamp", args_[8].instanceOf())
	}

	version, ok := args_[9].(rideInt)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for version", args_[9].instanceOf())
	}

	sender, ok := args_[10].(rideAddress)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for sender", args_[10].instanceOf())
	}

	senderPublicKey, ok := args_[11].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[11].instanceOf())
	}

	bodyBytes, ok := args_[12].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for bodyBytes", args_[12].instanceOf())
	}

	proofs, ok := args_[13].(rideList)
	if !ok {
		return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' for proofs", args_[13].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("exchangeTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideExchangeTransaction(proofs, buyOrder, sellOrder, id, bodyBytes, senderPublicKey, timestamp, price, amount, version, buyMatcherFee, fee, sellMatcherFee, sender), nil
}

func genesisTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 6); err != nil {
		return nil, errors.Wrap(err, "genesisTransactionConstructor")
	}

	amount, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for amount", args_[0].instanceOf())
	}

	var recipient rideType
	switch v := args_[1].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for recipient", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("genesisTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	return newRideGenesisTransaction(recipient, id, timestamp, amount, version, fee), nil
}

func invokeExpressionTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "invokeExpressionTransactionConstructor")
	}

	expression, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for expression", args_[0].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[1].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for feeAssetId", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("invokeExpressionTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideInvokeExpressionTransaction(proofs, feeAssetId, bodyBytes, id, expression, senderPublicKey, timestamp, version, fee, sender), nil
}

func invokeScriptTransactionV3Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 13); err != nil {
		return nil, errors.Wrap(err, "invokeScriptTransactionV3Constructor")
	}

	var dApp rideType
	switch v := args_[0].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		dApp = v
	default:
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for dApp", args_[0].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[1].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for feeAssetId", args_[1].instanceOf())
	}

	function, ok := args_[2].(rideString)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for function", args_[2].instanceOf())
	}

	args, ok := args_[3].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for args", args_[3].instanceOf())
	}
	// checks for list elements
	for _, el := range args {
		switch te := el.(type) {
		case rideList:
			for _, el := range te {
				switch te := el.(type) {
				case rideBoolean, rideByteVector, rideInt, rideString:
				default:
					return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' in args list", te.instanceOf())
				}
			}
		case rideBoolean, rideByteVector, rideInt, rideString:
		default:
			return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' in args list", te.instanceOf())
		}
	}

	id, ok := args_[4].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for id", args_[4].instanceOf())
	}

	fee, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for fee", args_[5].instanceOf())
	}

	timestamp, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for timestamp", args_[6].instanceOf())
	}

	version, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for version", args_[7].instanceOf())
	}

	sender, ok := args_[8].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for sender", args_[8].instanceOf())
	}

	senderPublicKey, ok := args_[9].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for senderPublicKey", args_[9].instanceOf())
	}

	bodyBytes, ok := args_[10].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for bodyBytes", args_[10].instanceOf())
	}

	var payment rideType
	switch v := args_[11].(type) {
	case rideAttachedPayment, rideUnit:
		payment = v
	default:
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for payment", args_[11].instanceOf())
	}

	proofs, ok := args_[12].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' for proofs", args_[12].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("invokeScriptTransactionV3Constructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideInvokeScriptTransactionV3(proofs, feeAssetId, dApp, function, bodyBytes, id, senderPublicKey, payment, args, timestamp, fee, version, sender), nil
}

func invokeScriptTransactionV4Constructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 13); err != nil {
		return nil, errors.Wrap(err, "invokeScriptTransactionV4Constructor")
	}

	var dApp rideType
	switch v := args_[0].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		dApp = v
	default:
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for dApp", args_[0].instanceOf())
	}

	var feeAssetId rideType
	switch v := args_[1].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for feeAssetId", args_[1].instanceOf())
	}

	function, ok := args_[2].(rideString)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for function", args_[2].instanceOf())
	}

	args, ok := args_[3].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for args", args_[3].instanceOf())
	}
	// checks for list elements
	for _, el := range args {
		switch te := el.(type) {
		case rideList:
			for _, el := range te {
				switch te := el.(type) {
				case rideBoolean, rideByteVector, rideInt, rideString:
				default:
					return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' in args list", te.instanceOf())
				}
			}
		case rideBoolean, rideByteVector, rideInt, rideString:
		default:
			return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' in args list", te.instanceOf())
		}
	}

	id, ok := args_[4].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for id", args_[4].instanceOf())
	}

	fee, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for fee", args_[5].instanceOf())
	}

	timestamp, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for timestamp", args_[6].instanceOf())
	}

	version, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for version", args_[7].instanceOf())
	}

	sender, ok := args_[8].(rideAddress)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for sender", args_[8].instanceOf())
	}

	senderPublicKey, ok := args_[9].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for senderPublicKey", args_[9].instanceOf())
	}

	bodyBytes, ok := args_[10].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for bodyBytes", args_[10].instanceOf())
	}

	payments, ok := args_[11].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for payments", args_[11].instanceOf())
	}
	// checks for list elements
	for _, el := range payments {
		switch te := el.(type) {
		case rideAttachedPayment:
		default:
			return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' in payments list", te.instanceOf())
		}
	}

	proofs, ok := args_[12].(rideList)
	if !ok {
		return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' for proofs", args_[12].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("invokeScriptTransactionV4Constructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideInvokeScriptTransactionV4(proofs, feeAssetId, dApp, function, bodyBytes, id, senderPublicKey, payments, args, timestamp, fee, version, sender), nil
}

func issueTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 14); err != nil {
		return nil, errors.Wrap(err, "issueTransactionConstructor")
	}

	quantity, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for quantity", args_[0].instanceOf())
	}

	name, ok := args_[1].(rideString)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for name", args_[1].instanceOf())
	}

	description, ok := args_[2].(rideString)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for description", args_[2].instanceOf())
	}

	reissuable, ok := args_[3].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for reissuable", args_[3].instanceOf())
	}

	decimals, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for decimals", args_[4].instanceOf())
	}

	var script rideType
	switch v := args_[5].(type) {
	case rideByteVector, rideUnit:
		script = v
	default:
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for script", args_[5].instanceOf())
	}

	id, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for id", args_[6].instanceOf())
	}

	fee, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for fee", args_[7].instanceOf())
	}

	timestamp, ok := args_[8].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for timestamp", args_[8].instanceOf())
	}

	version, ok := args_[9].(rideInt)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for version", args_[9].instanceOf())
	}

	sender, ok := args_[10].(rideAddress)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for sender", args_[10].instanceOf())
	}

	senderPublicKey, ok := args_[11].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[11].instanceOf())
	}

	bodyBytes, ok := args_[12].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for bodyBytes", args_[12].instanceOf())
	}

	proofs, ok := args_[13].(rideList)
	if !ok {
		return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' for proofs", args_[13].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("issueTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideIssueTransaction(proofs, script, description, name, bodyBytes, id, senderPublicKey, timestamp, version, fee, quantity, decimals, reissuable, sender), nil
}

func leaseCancelTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 9); err != nil {
		return nil, errors.Wrap(err, "leaseCancelTransactionConstructor")
	}

	leaseId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for leaseId", args_[0].instanceOf())
	}

	id, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for id", args_[1].instanceOf())
	}

	fee, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for fee", args_[2].instanceOf())
	}

	timestamp, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for timestamp", args_[3].instanceOf())
	}

	version, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for version", args_[4].instanceOf())
	}

	sender, ok := args_[5].(rideAddress)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for sender", args_[5].instanceOf())
	}

	senderPublicKey, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[6].instanceOf())
	}

	bodyBytes, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for bodyBytes", args_[7].instanceOf())
	}

	proofs, ok := args_[8].(rideList)
	if !ok {
		return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' for proofs", args_[8].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("leaseCancelTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideLeaseCancelTransaction(proofs, bodyBytes, senderPublicKey, id, leaseId, timestamp, version, fee, sender), nil
}

func leaseTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "leaseTransactionConstructor")
	}

	amount, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for amount", args_[0].instanceOf())
	}

	var recipient rideType
	switch v := args_[1].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for recipient", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("leaseTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideLeaseTransaction(proofs, recipient, bodyBytes, id, senderPublicKey, timestamp, amount, version, fee, sender), nil
}

func massTransferTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 13); err != nil {
		return nil, errors.Wrap(err, "massTransferTransactionConstructor")
	}

	var assetId rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		assetId = v
	default:
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	totalAmount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for totalAmount", args_[1].instanceOf())
	}

	transfers, ok := args_[2].(rideList)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for transfers", args_[2].instanceOf())
	}
	// checks for list elements
	for _, el := range transfers {
		switch te := el.(type) {
		case rideTransfer:
		default:
			return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' in transfers list", te.instanceOf())
		}
	}

	transferCount, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for transferCount", args_[3].instanceOf())
	}

	attachment, ok := args_[4].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for attachment", args_[4].instanceOf())
	}

	id, ok := args_[5].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for id", args_[5].instanceOf())
	}

	fee, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for fee", args_[6].instanceOf())
	}

	timestamp, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for timestamp", args_[7].instanceOf())
	}

	version, ok := args_[8].(rideInt)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for version", args_[8].instanceOf())
	}

	sender, ok := args_[9].(rideAddress)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for sender", args_[9].instanceOf())
	}

	senderPublicKey, ok := args_[10].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[10].instanceOf())
	}

	bodyBytes, ok := args_[11].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for bodyBytes", args_[11].instanceOf())
	}

	proofs, ok := args_[12].(rideList)
	if !ok {
		return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' for proofs", args_[12].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("massTransferTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideMassTransferTransaction(proofs, assetId, bodyBytes, id, senderPublicKey, attachment, transfers, transferCount, timestamp, fee, totalAmount, version, sender), nil
}

func paymentTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "paymentTransactionConstructor")
	}

	amount, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for amount", args_[0].instanceOf())
	}

	var recipient rideType
	switch v := args_[1].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for recipient", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("paymentTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRidePaymentTransaction(proofs, recipient, bodyBytes, id, senderPublicKey, timestamp, amount, version, fee, sender), nil
}

func reissueTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 11); err != nil {
		return nil, errors.Wrap(err, "reissueTransactionConstructor")
	}

	quantity, ok := args_[0].(rideInt)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for quantity", args_[0].instanceOf())
	}

	assetId, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for assetId", args_[1].instanceOf())
	}

	reissuable, ok := args_[2].(rideBoolean)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for reissuable", args_[2].instanceOf())
	}

	id, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for id", args_[3].instanceOf())
	}

	fee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for fee", args_[4].instanceOf())
	}

	timestamp, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for timestamp", args_[5].instanceOf())
	}

	version, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for version", args_[6].instanceOf())
	}

	sender, ok := args_[7].(rideAddress)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for sender", args_[7].instanceOf())
	}

	senderPublicKey, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[8].instanceOf())
	}

	bodyBytes, ok := args_[9].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for bodyBytes", args_[9].instanceOf())
	}

	proofs, ok := args_[10].(rideList)
	if !ok {
		return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' for proofs", args_[10].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("reissueTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideReissueTransaction(bodyBytes, proofs, senderPublicKey, assetId, id, timestamp, version, quantity, fee, sender, reissuable), nil
}

func setAssetScriptTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "setAssetScriptTransactionConstructor")
	}

	var script rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		script = v
	default:
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for script", args_[0].instanceOf())
	}

	assetId, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for assetId", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("setAssetScriptTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideSetAssetScriptTransaction(proofs, script, bodyBytes, assetId, id, senderPublicKey, timestamp, version, fee, sender), nil
}

func setScriptTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 9); err != nil {
		return nil, errors.Wrap(err, "setScriptTransactionConstructor")
	}

	var script rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		script = v
	default:
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for script", args_[0].instanceOf())
	}

	id, ok := args_[1].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for id", args_[1].instanceOf())
	}

	fee, ok := args_[2].(rideInt)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for fee", args_[2].instanceOf())
	}

	timestamp, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for timestamp", args_[3].instanceOf())
	}

	version, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for version", args_[4].instanceOf())
	}

	sender, ok := args_[5].(rideAddress)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for sender", args_[5].instanceOf())
	}

	senderPublicKey, ok := args_[6].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[6].instanceOf())
	}

	bodyBytes, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for bodyBytes", args_[7].instanceOf())
	}

	proofs, ok := args_[8].(rideList)
	if !ok {
		return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' for proofs", args_[8].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("setScriptTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideSetScriptTransaction(proofs, script, bodyBytes, id, senderPublicKey, timestamp, version, fee, sender), nil
}

func sponsorFeeTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 10); err != nil {
		return nil, errors.Wrap(err, "sponsorFeeTransactionConstructor")
	}

	assetId, ok := args_[0].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	var minSponsoredAssetFee rideType
	switch v := args_[1].(type) {
	case rideInt, rideUnit:
		minSponsoredAssetFee = v
	default:
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for minSponsoredAssetFee", args_[1].instanceOf())
	}

	id, ok := args_[2].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for id", args_[2].instanceOf())
	}

	fee, ok := args_[3].(rideInt)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for fee", args_[3].instanceOf())
	}

	timestamp, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for timestamp", args_[4].instanceOf())
	}

	version, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for version", args_[5].instanceOf())
	}

	sender, ok := args_[6].(rideAddress)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for sender", args_[6].instanceOf())
	}

	senderPublicKey, ok := args_[7].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[7].instanceOf())
	}

	bodyBytes, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for bodyBytes", args_[8].instanceOf())
	}

	proofs, ok := args_[9].(rideList)
	if !ok {
		return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' for proofs", args_[9].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("sponsorFeeTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideSponsorFeeTransaction(proofs, minSponsoredAssetFee, bodyBytes, assetId, id, senderPublicKey, timestamp, version, fee, sender), nil
}

func transferTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 13); err != nil {
		return nil, errors.Wrap(err, "transferTransactionConstructor")
	}

	var feeAssetId rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		feeAssetId = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for feeAssetId", args_[0].instanceOf())
	}

	amount, ok := args_[1].(rideInt)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for amount", args_[1].instanceOf())
	}

	var assetId rideType
	switch v := args_[2].(type) {
	case rideByteVector, rideUnit:
		assetId = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for assetId", args_[2].instanceOf())
	}

	var recipient rideType
	switch v := args_[3].(type) {
	case rideAlias, rideAddress, rideAddressLike:
		recipient = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for recipient", args_[3].instanceOf())
	}

	var attachment rideType
	switch v := args_[4].(type) {
	case rideByteVector, rideUnit:
		attachment = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for attachment", args_[4].instanceOf())
	}

	id, ok := args_[5].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for id", args_[5].instanceOf())
	}

	var fee rideType
	switch v := args_[6].(type) {
	case rideInt, rideUnit:
		fee = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for fee", args_[6].instanceOf())
	}

	timestamp, ok := args_[7].(rideInt)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for timestamp", args_[7].instanceOf())
	}

	var version rideType
	switch v := args_[8].(type) {
	case rideInt, rideUnit:
		version = v
	default:
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for version", args_[8].instanceOf())
	}

	sender, ok := args_[9].(rideAddress)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for sender", args_[9].instanceOf())
	}

	senderPublicKey, ok := args_[10].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[10].instanceOf())
	}

	bodyBytes, ok := args_[11].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for bodyBytes", args_[11].instanceOf())
	}

	proofs, ok := args_[12].(rideList)
	if !ok {
		return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' for proofs", args_[12].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("transferTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideTransferTransaction(assetId, bodyBytes, feeAssetId, version, attachment, proofs, fee, recipient, id, senderPublicKey, timestamp, amount, sender), nil
}

func updateAssetInfoTransactionConstructor(_ environment, args_ ...rideType) (rideType, error) {
	if err := checkArgs(args_, 11); err != nil {
		return nil, errors.Wrap(err, "updateAssetInfoTransactionConstructor")
	}

	var assetId rideType
	switch v := args_[0].(type) {
	case rideByteVector, rideUnit:
		assetId = v
	default:
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for assetId", args_[0].instanceOf())
	}

	name, ok := args_[1].(rideString)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for name", args_[1].instanceOf())
	}

	description, ok := args_[2].(rideString)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for description", args_[2].instanceOf())
	}

	id, ok := args_[3].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for id", args_[3].instanceOf())
	}

	fee, ok := args_[4].(rideInt)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for fee", args_[4].instanceOf())
	}

	timestamp, ok := args_[5].(rideInt)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for timestamp", args_[5].instanceOf())
	}

	version, ok := args_[6].(rideInt)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for version", args_[6].instanceOf())
	}

	sender, ok := args_[7].(rideAddress)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for sender", args_[7].instanceOf())
	}

	senderPublicKey, ok := args_[8].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for senderPublicKey", args_[8].instanceOf())
	}

	bodyBytes, ok := args_[9].(rideByteVector)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for bodyBytes", args_[9].instanceOf())
	}

	proofs, ok := args_[10].(rideList)
	if !ok {
		return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' for proofs", args_[10].instanceOf())
	}
	// checks for list elements
	for _, el := range proofs {
		switch te := el.(type) {
		case rideByteVector:
		default:
			return nil, errors.Errorf("updateAssetInfoTransactionConstructor: unexpected type '%s' in proofs list", te.instanceOf())
		}
	}

	return newRideUpdateAssetInfoTransaction(proofs, assetId, name, description, bodyBytes, id, senderPublicKey, timestamp, version, fee, sender), nil
}