service

type CodeWithMetadata struct {
	Metadata []byte // a_m
	Code     []byte // a_c
}

type DeferredTransfer struct {
	SenderServiceIndex   block.ServiceId // sender service index (s)
	ReceiverServiceIndex block.ServiceId // receiver service index (d)
	Balance              uint64          // balance value (a)
	Memo                 Memo            // memo (m)
	GasLimit             uint64          // gas limit (g)
}

type Memo [TransferMemoSizeBytes]byte

type PreImageMetaKey struct {
	Hash   crypto.Hash    // Hash of the preimage ()
	Length PreimageLength // Length (presupposed) of the preimage ()
}

type PreimageHistoricalTimeslots []jamtime.Timeslot // Metadata for preimages (l) - TODO: There is a MaxHistoricalTimeslotsForPreimageMeta.

type PreimageLength uint32

type PrivilegedServices struct {
	ManagerServiceId        block.ServiceId            // Manager service ID (m) - the service able to effect an alteration of PrivilegedServices from block to block. Also called Empower service.
	AssignServiceId         block.ServiceId            // Assign service ID (a) - the service able to effect an alteration of the PendingAuthorizersQueues.
	DesignateServiceId      block.ServiceId            // Designate service ID (v) - the service able to effect an alteration of the NextValidators in ValidatorState.
	AmountOfGasPerServiceId map[block.ServiceId]uint64 // Amount of gas per service ID (g) - small dictionary containing the indices of services which automatically accumulate in each block together with a basic amount of gas with which each accumulates.
}

type ServiceAccount struct {
	// Storage uses a state key for it's key. We have to use the state key
	// representation as the key because serializing storage keys is lossy and
	// we'd like to be able to deserialize the storage dictionary later. Host
	// calls are called by PVM code code with the original storage key. The key
	// we end up using is merely an implementation detail. As long as we can
	// store and retrieve the key we are fine, we don't need to know the
	// original key here.
	Storage                map[statekey.StateKey][]byte                    // Dictionary of key-value pairs for storage (s)
	PreimageLookup         map[crypto.Hash][]byte                          // Dictionary of preimage lookups (p)
	PreimageMeta           map[PreImageMetaKey]PreimageHistoricalTimeslots // Metadata for preimageLookup (l) Graypaper 0.6.3 - TODO: There is a MaxTimeslotsForPreimage.
	CodeHash               crypto.Hash                                     // Hash of the service code (c)
	Balance                uint64                                          // Balance of the service (b)
	GasLimitForAccumulator uint64                                          // Gas limit for accumulation (g)
	GasLimitOnTransfer     uint64                                          // Gas limit for on_transfer (m)
}

type ServiceState map[block.ServiceId]ServiceAccount