@synopackageland/cli 0.5.3 → 0.6.1

package/dist/templates/native-go/backend/internal/helper/grant_delivery_methods.go

@@ -1,273 +0,0 @@
-package helper
-
-import (
-	"context"
-	"crypto/rand"
-	"encoding/hex"
-	"io"
-	"net"
-	"slices"
-	"time"
-)
-
-func validDeliveryEpoch(i Inventory, epoch string) Code {
-	if !i.Valid() || i.Protocol != DataProtocol {
-		return ErrIncompatible
-	}
-	if !digestPattern.MatchString(epoch) {
-		return ErrInvalid
-	}
-	return ""
-}
-
-func newOperationTickets(i Inventory, epoch string) (*operationTickets, Code) {
-	if c := validDeliveryEpoch(i, epoch); c != "" {
-		return nil, c
-	}
-	return &operationTickets{inventory: i, epoch: epoch, now: time.Now, random: rand.Reader, issued: map[string]issuedOperationTicket{}}, ""
-}
-
-func deliveryActorCode(a NativeActor, now time.Time) Code {
-	if !a.valid || !a.account.Enabled || a.UID() == 0 || a.GID() == 0 {
-		return ErrDenied
-	}
-	if a.Principal().Kind != "local" {
-		return ErrUnsupported
-	}
-	if !allReferences(a.Principal().SubjectRef, a.Principal().InstanceRef, a.SessionRef()) || a.account.Groups == nil {
-		return ErrSuspended
-	}
-	if !nativeFresh(a.account.CheckedAt, now) {
-		return ErrStale
-	}
-	return ""
-}
-
-// issue is called only after trusted native/App/ACL observation, never in
-// response to caller identity claims. It does not grant filesystem admission.
-// A caller ticket is refused; the returned control contains a CSPRNG ticket
-// bound to that exact decoded request, including its argument bytes.
-func (t *operationTickets) issue(ctx context.Context, actor NativeActor, request DataRequest) (DataRequest, Code) {
-	if t == nil {
-		return DataRequest{}, ErrUnavailable
-	}
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	if t.closed || t.now == nil || t.random == nil || t.issued == nil {
-		return DataRequest{}, ErrUnavailable
-	}
-	if code := nativeContextCode(ctx); code != "" {
-		return DataRequest{}, code
-	}
-	if code := deliveryActorCode(actor, t.now()); code != "" {
-		return DataRequest{}, code
-	}
-	if request.Inventory != t.inventory || request.Epoch != t.epoch {
-		return DataRequest{}, ErrStale
-	}
-	if request.Ticket != "" {
-		return DataRequest{}, ErrInvalid
-	}
-	full := len(t.issued)-t.streamIssued >= MaxReplayEntries
-	if request.Op == ActionReadStream || request.Op == ActionWriteStream {
-		full = t.streamIssued >= MaxStreamReplayEntries
-	}
-	if full {
-		return DataRequest{}, ErrBusy
-	}
-	// Validate before drawing randomness. The temporary reference is never used
-	// as a credential or published; syntax validation requires a ticket-shaped ID.
-	request.Ticket = t.epoch
-	if code := validateOperationRequest(request, t.writes); code != "" {
-		return DataRequest{}, code
-	}
-	if !request.Op.ReadOnly() && !t.writes.allows(request.Op) {
-		return DataRequest{}, ErrUnsupported
-	}
-	var token [32]byte
-	if _, err := io.ReadFull(t.random, token[:]); err != nil {
-		return DataRequest{}, ErrUnavailable
-	}
-	if code := nativeContextCode(ctx); code != "" {
-		return DataRequest{}, code
-	}
-	now := t.now()
-	if code := deliveryActorCode(actor, now); code != "" {
-		return DataRequest{}, code
-	}
-	request.Ticket = hex.EncodeToString(token[:])
-	if _, exists := t.issued[request.Ticket]; exists {
-		return DataRequest{}, ErrUnavailable
-	}
-	request.Args = slices.Clone(request.Args)
-	binding := TicketBinding{Inventory: request.Inventory, Epoch: request.Epoch, SubjectRef: actor.Principal().SubjectRef, SessionRef: actor.SessionRef(), Action: request.Op, GrantID: request.GrantID, GrantRevision: request.GrantRevision, OperationID: request.OperationID, Nonce: request.Nonce, Ticket: request.Ticket, RequestDigest: request.Digest(), ExpiresAt: now.Add(IntentTTL)}
-	if binding.RequestDigest == "" {
-		return DataRequest{}, ErrInvalid
-	}
-	t.issued[request.Ticket] = issuedOperationTicket{binding: binding, principal: actor.Principal()}
-	if request.Op == ActionReadStream || request.Op == ActionWriteStream {
-		t.streamIssued++
-	}
-	return request, ""
-}
-
-// consume burns only an exact issued control. S3 must still freshly revalidate
-// native/App/ACL/continuity and consume its own admission history under its gate.
-// An admission failure may burn this ticket; retries require a new ticket.
-func (t *operationTickets) consume(ctx context.Context, actor NativeActor, request DataRequest) (TicketBinding, Code) {
-	if t == nil {
-		return TicketBinding{}, ErrUnavailable
-	}
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	if t.closed || t.now == nil || t.issued == nil {
-		return TicketBinding{}, ErrUnavailable
-	}
-	if code := nativeContextCode(ctx); code != "" {
-		return TicketBinding{}, code
-	}
-	now := t.now()
-	if code := deliveryActorCode(actor, now); code != "" {
-		return TicketBinding{}, code
-	}
-	if code := validateOperationRequest(request, t.writes); code != "" {
-		return TicketBinding{}, code
-	}
-	issued, ok := t.issued[request.Ticket]
-	if !ok {
-		return TicketBinding{}, ErrDenied
-	}
-	b := issued.binding
-	if actor.Principal() != issued.principal || actor.SessionRef() != b.SessionRef || request.Digest() != b.RequestDigest {
-		return TicketBinding{}, ErrDenied
-	}
-	if issued.used {
-		return TicketBinding{}, ErrReplay
-	}
-	if !now.Before(b.ExpiresAt) {
-		return TicketBinding{}, ErrExpired
-	}
-	if b.ExpiresAt.Sub(now) > IntentTTL {
-		return TicketBinding{}, ErrStale
-	}
-	issued.used = true
-	t.issued[request.Ticket] = issued
-	return b, ""
-}
-func (t *operationTickets) close() {
-	if t == nil {
-		return
-	}
-	t.mu.Lock()
-	defer t.mu.Unlock()
-	t.closed = true
-}
-
-func newOutputHandoff(i Inventory, epoch string) (*outputHandoff, Code) {
-	if code := validDeliveryEpoch(i, epoch); code != "" {
-		return nil, code
-	}
-	return &outputHandoff{inventory: i, epoch: epoch, now: time.Now, entries: map[string]operationOutput{}}, ""
-}
-func validOutputBinding(b operationBinding, i Inventory, epoch string) bool {
-	return b.Inventory == i && b.Epoch == epoch && allReferences(b.OperationID, b.Nonce, b.GrantID) && b.GrantRevision > 0
-}
-
-// register takes ownership even on rejection. Caller must have authenticated
-// the fixed owned peer and associated this endpoint with the admitted request.
-// Never call this with a browser-supplied operation binding or remote address.
-func (h *outputHandoff) register(b operationBinding, conn net.Conn) (code Code) {
-	if conn == nil {
-		return ErrInvalid
-	}
-	defer func() {
-		if code != "" {
-			conn.Close()
-		}
-	}()
-	if h == nil {
-		return ErrUnavailable
-	}
-	h.mu.Lock()
-	defer h.mu.Unlock()
-	if h.closed || h.now == nil || h.entries == nil {
-		return ErrUnavailable
-	}
-	if !validOutputBinding(b, h.inventory, h.epoch) {
-		return ErrDenied
-	}
-	if _, ok := h.entries[b.OperationID]; ok {
-		return ErrReplay
-	}
-	if len(h.entries) >= MaxReplayEntries {
-		return ErrBusy
-	}
-	now := h.now()
-	if now.IsZero() {
-		return ErrUnavailable
-	}
-	h.entries[b.OperationID] = operationOutput{binding: b, conn: conn, expires: now.Add(BoundedTimeout)}
-	return ""
-}
-
-// take transfers ownership to S2. All net.Conn.Close calls occur after dropping
-// the handoff lock. Close/timeout here is not child-reap or Q evidence.
-func (h *outputHandoff) take(b operationBinding) (net.Conn, Code) {
-	if h == nil {
-		return nil, ErrUnavailable
-	}
-	h.mu.Lock()
-	if h.closed || h.now == nil || h.entries == nil {
-		h.mu.Unlock()
-		return nil, ErrUnavailable
-	}
-	entry, ok := h.entries[b.OperationID]
-	if !validOutputBinding(b, h.inventory, h.epoch) || !ok || entry.binding != b {
-		h.mu.Unlock()
-		return nil, ErrDenied
-	}
-	if entry.taken {
-		h.mu.Unlock()
-		return nil, ErrReplay
-	}
-	if now := h.now(); now.IsZero() || !now.Before(entry.expires) || entry.expires.Sub(now) > BoundedTimeout {
-		conn := entry.conn
-		entry.conn = nil
-		entry.taken = true
-		h.entries[b.OperationID] = entry
-		h.mu.Unlock()
-		if conn != nil {
-			conn.Close()
-		}
-		return nil, ErrExpired
-	}
-	if entry.conn == nil {
-		h.mu.Unlock()
-		return nil, ErrUnavailable
-	}
-	conn := entry.conn
-	entry.conn = nil
-	entry.taken = true
-	h.entries[b.OperationID] = entry
-	h.mu.Unlock()
-	return conn, ""
-}
-func (h *outputHandoff) close() {
-	if h == nil {
-		return
-	}
-	h.mu.Lock()
-	h.closed = true
-	var pending []net.Conn
-	for id, entry := range h.entries {
-		if entry.conn != nil {
-			pending = append(pending, entry.conn)
-			entry.conn = nil
-			h.entries[id] = entry
-		}
-	}
-	h.mu.Unlock()
-	for _, conn := range pending {
-		conn.Close()
-	}
-}

package/dist/templates/native-go/backend/internal/helper/grant_delivery_test.go

@@ -1,322 +0,0 @@
-package helper
-
-import (
-	"context"
-	"fmt"
-	"io"
-	"net"
-	"slices"
-	"strings"
-	"sync"
-	"testing"
-	"time"
-)
-
-func deliveryFixture(t *testing.T) (*operationTickets, NativeActor, DataRequest, time.Time) {
-	t.Helper()
-	provider, _, _, carriers, now := nativeFixture()
-	actor, code := provider.Resolve(context.Background(), carriers)
-	if code != "" {
-		t.Fatal(code)
-	}
-	request, _, _ := validRequestAndTicket(t)
-	request.Ticket = ""
-	tickets, code := newOperationTickets(request.Inventory, request.Epoch)
-	if code != "" {
-		t.Fatal(code)
-	}
-	tickets.now = func() time.Time { return now }
-	return tickets, actor, request, now
-}
-
-func TestOperationTicketsServerIssuedAndCompleteBinding(t *testing.T) {
-	tickets, actor, request, _ := deliveryFixture(t)
-	issued, code := tickets.issue(context.Background(), actor, request)
-	if code != "" || !digestPattern.MatchString(issued.Ticket) {
-		t.Fatal(code, issued.Ticket)
-	}
-	original := issued
-	issued.Args = slices.Clone(issued.Args)
-	issued.Args[0] = ' '
-	if _, code = tickets.consume(context.Background(), actor, issued); code == "" {
-		t.Fatal("changed arguments accepted")
-	}
-	proof, code := tickets.consume(context.Background(), actor, original)
-	if code != "" || proof.Ticket != original.Ticket || proof.RequestDigest != original.Digest() || proof.SubjectRef != actor.Principal().SubjectRef || proof.SessionRef != actor.SessionRef() {
-		t.Fatal(code, proof)
-	}
-	if _, code = tickets.consume(context.Background(), actor, original); code != ErrReplay {
-		t.Fatal("replay", code)
-	}
-	if _, code = tickets.consume(context.Background(), actor, request); code == "" {
-		t.Fatal("missing ticket accepted")
-	}
-}
-
-func TestOperationTicketsRejectUnknownProofAndEverySubstitution(t *testing.T) {
-	mutations := []struct {
-		name   string
-		mutate func(*DataRequest, *NativeActor)
-	}{
-		{"inventory", func(r *DataRequest, a *NativeActor) { r.Inventory.Version = "9.0.0-9999" }},
-		{"epoch", func(r *DataRequest, a *NativeActor) { r.Epoch = strings.Repeat("a", 64) }},
-		{"grant", func(r *DataRequest, a *NativeActor) { r.GrantID = strings.Repeat("a", 64) }},
-		{"revision", func(r *DataRequest, a *NativeActor) { r.GrantRevision++ }},
-		{"operation", func(r *DataRequest, a *NativeActor) { r.OperationID = strings.Repeat("a", 64) }},
-		{"nonce", func(r *DataRequest, a *NativeActor) { r.Nonce = strings.Repeat("a", 64) }},
-		{"ticket", func(r *DataRequest, a *NativeActor) { r.Ticket = strings.Repeat("a", 64) }},
-		{"session", func(r *DataRequest, a *NativeActor) { a.sessionRef = strings.Repeat("a", 64) }},
-		{"instance", func(r *DataRequest, a *NativeActor) { a.account.Principal.InstanceRef = strings.Repeat("a", 64) }},
-		{"unknown actor", func(r *DataRequest, a *NativeActor) { *a = NativeActor{} }},
-	}
-	for _, m := range mutations {
-		t.Run(m.name, func(t *testing.T) {
-			tickets, actor, request, _ := deliveryFixture(t)
-			issued, code := tickets.issue(context.Background(), actor, request)
-			if code != "" {
-				t.Fatal(code)
-			}
-			badActor := actor
-			bad := issued
-			m.mutate(&bad, &badActor)
-			if _, code = tickets.consume(context.Background(), badActor, bad); code == "" {
-				t.Fatal("substitution accepted")
-			}
-			if _, code = tickets.consume(context.Background(), actor, issued); code != "" {
-				t.Fatal("rejection burned valid ticket", code)
-			}
-		})
-	}
-	tickets, actor, request, now := deliveryFixture(t)
-	unknown := actor
-	unknown.account.Principal.InstanceRef = ""
-	if _, code := tickets.issue(context.Background(), unknown, request); code == "" {
-		t.Fatal("unknown incarnation")
-	}
-	unknown = actor
-	unknown.account.Groups = nil
-	if _, code := tickets.issue(context.Background(), unknown, request); code == "" {
-		t.Fatal("unknown groups")
-	}
-	tickets.now = func() time.Time { return now.Add(NativeProofFreshness + time.Nanosecond) }
-	if _, code := tickets.issue(context.Background(), actor, request); code != ErrStale {
-		t.Fatal("stale native proof", code)
-	}
-}
-
-func TestOperationTicketsBoundsExpiryCancelAndClose(t *testing.T) {
-	tickets, actor, request, now := deliveryFixture(t)
-	bad := request
-	bad.Ticket = strings.Repeat("f", 64)
-	if _, code := tickets.issue(context.Background(), actor, bad); code != ErrInvalid {
-		t.Fatal("caller chose ticket", code)
-	}
-	issued, code := tickets.issue(context.Background(), actor, request)
-	if code != "" {
-		t.Fatal(code)
-	}
-	ctx, cancel := context.WithCancel(context.Background())
-	cancel()
-	if _, code = tickets.consume(ctx, actor, issued); code != ErrCanceled {
-		t.Fatal(code)
-	}
-	tickets.now = func() time.Time { return now.Add(IntentTTL) }
-	actor.account.CheckedAt = now.Add(IntentTTL)
-	if _, code = tickets.consume(context.Background(), actor, issued); code != ErrExpired {
-		t.Fatal(code)
-	}
-	tickets.now = func() time.Time { return now }
-	actor.account.CheckedAt = now
-	for len(tickets.issued) < MaxReplayEntries {
-		if _, code = tickets.issue(context.Background(), actor, request); code != "" {
-			t.Fatal(code)
-		}
-	}
-	if _, code = tickets.issue(context.Background(), actor, request); code != ErrBusy {
-		t.Fatal("capacity evicted expired ticket", code)
-	}
-	tickets.close()
-	if _, code = tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
-		t.Fatal(code)
-	}
-	var absent *operationTickets
-	if _, code = absent.consume(context.Background(), actor, issued); code != ErrUnavailable {
-		t.Fatal(code)
-	}
-	if _, code = newOperationTickets(Inventory{}, request.Epoch); code == "" {
-		t.Fatal("invalid inventory")
-	}
-}
-
-func TestOperationTicketsRandomFailureCollisionAndConcurrentUse(t *testing.T) {
-	tickets, actor, request, _ := deliveryFixture(t)
-	tickets.random = strings.NewReader("")
-	if _, code := tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
-		t.Fatal(code)
-	}
-	tickets.random = strings.NewReader(strings.Repeat("x", 64))
-	issued, code := tickets.issue(context.Background(), actor, request)
-	if code != "" {
-		t.Fatal(code)
-	}
-	if _, code = tickets.issue(context.Background(), actor, request); code != ErrUnavailable {
-		t.Fatal("collision replaced ticket", code)
-	}
-	results := make(chan Code, 16)
-	var wg sync.WaitGroup
-	for i := 0; i < 16; i++ {
-		wg.Add(1)
-		go func() { defer wg.Done(); _, c := tickets.consume(context.Background(), actor, issued); results <- c }()
-	}
-	wg.Wait()
-	close(results)
-	success := 0
-	for c := range results {
-		if c == "" {
-			success++
-		} else if c != ErrReplay {
-			t.Fatal(c)
-		}
-	}
-	if success != 1 {
-		t.Fatal("single use", success)
-	}
-}
-
-func outputFixture(t *testing.T) (*outputHandoff, operationBinding, time.Time) {
-	t.Helper()
-	r, _, now := validRequestAndTicket(t)
-	h, c := newOutputHandoff(r.Inventory, r.Epoch)
-	if c != "" {
-		t.Fatal(c)
-	}
-	h.now = func() time.Time { return now }
-	b := operationBinding{r.Inventory, r.Epoch, r.OperationID, r.Nonce, r.GrantID, r.GrantRevision}
-	return h, b, now
-}
-
-func TestOutputHandoffExactBindingAndSingleUse(t *testing.T) {
-	h, b, _ := outputFixture(t)
-	writer, reader := net.Pipe()
-	defer reader.Close()
-	if c := h.register(b, writer); c != "" {
-		t.Fatal(c)
-	}
-	bad := b
-	bad.Nonce = strings.Repeat("a", 64)
-	if out, c := h.take(bad); c != ErrDenied || out != nil {
-		t.Fatal("substitution", c)
-	}
-	out, c := h.take(b)
-	if c != "" || out != writer {
-		t.Fatal(c)
-	}
-	defer out.Close()
-	if out, c := h.take(b); c != ErrReplay || out != nil {
-		t.Fatal(c)
-	}
-	h.close() // transferred endpoint belongs to S2; Close cannot steal it.
-	done := make(chan error, 1)
-	go func() { _, err := writer.Write([]byte("ok")); done <- err }()
-	reader.SetReadDeadline(time.Now().Add(time.Second))
-	buf := make([]byte, 2)
-	if _, err := io.ReadFull(reader, buf); err != nil || string(buf) != "ok" {
-		t.Fatal(err)
-	}
-	if err := <-done; err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestOutputHandoffUnknownExpiredDuplicateClosed(t *testing.T) {
-	for _, name := range []string{"expired", "duplicate", "closed", "invalid"} {
-		t.Run(name, func(t *testing.T) {
-			h, b, now := outputFixture(t)
-			w, r := net.Pipe()
-			defer r.Close()
-			switch name {
-			case "expired":
-				if c := h.register(b, w); c != "" {
-					t.Fatal(c)
-				}
-				h.now = func() time.Time { return now.Add(BoundedTimeout) }
-				if out, c := h.take(b); c != ErrExpired || out != nil {
-					t.Fatal(c)
-				}
-			case "duplicate":
-				old, oldReader := net.Pipe()
-				defer oldReader.Close()
-				defer h.close()
-				if c := h.register(b, old); c != "" {
-					t.Fatal(c)
-				}
-				if c := h.register(b, w); c != ErrReplay {
-					t.Fatal(c)
-				}
-			case "closed":
-				h.close()
-				if c := h.register(b, w); c != ErrUnavailable {
-					t.Fatal(c)
-				}
-			case "invalid":
-				b.Epoch = ""
-				if c := h.register(b, w); c == "" {
-					t.Fatal("invalid binding accepted")
-				}
-			}
-			r.SetReadDeadline(time.Now().Add(time.Second))
-			if _, err := r.Read(make([]byte, 1)); err != io.EOF {
-				t.Fatal("refused connection leaked", err)
-			}
-		})
-	}
-	h, b, _ := outputFixture(t)
-	if out, c := h.take(b); c != ErrDenied || out != nil {
-		t.Fatal("unknown output", c)
-	}
-	if c := h.register(b, nil); c != ErrInvalid {
-		t.Fatal("nil transport", c)
-	}
-	var absent *outputHandoff
-	if out, c := absent.take(b); c != ErrUnavailable || out != nil {
-		t.Fatal(c)
-	}
-}
-
-func TestOutputHandoffCapAndClosePending(t *testing.T) {
-	h, b, _ := outputFixture(t)
-	for i := 0; i < MaxReplayEntries; i++ {
-		x := b
-		x.OperationID = fmt.Sprintf("%064x", i+100)
-		w, r := net.Pipe()
-		r.Close()
-		if c := h.register(x, w); c != "" {
-			t.Fatal(c)
-		}
-		out, c := h.take(x)
-		if c != "" {
-			t.Fatal(c)
-		}
-		out.Close()
-	}
-	w, r := net.Pipe()
-	defer r.Close()
-	if c := h.register(b, w); c != ErrBusy {
-		t.Fatal("history evicted", c)
-	}
-	h, b, _ = outputFixture(t)
-	w, r = net.Pipe()
-	defer r.Close()
-	if c := h.register(b, w); c != "" {
-		t.Fatal(c)
-	}
-	h.close()
-	h.close()
-	if out, c := h.take(b); c != ErrUnavailable || out != nil {
-		t.Fatal(c)
-	}
-	r.SetReadDeadline(time.Now().Add(time.Second))
-	if _, err := r.Read(make([]byte, 1)); err != io.EOF {
-		t.Fatal(err)
-	}
-}

package/dist/templates/native-go/backend/internal/helper/grant_operation_contract.go

@@ -1,47 +0,0 @@
-package helper
-
-import (
-	"context"
-	"net"
-)
-
-// Root-only S1/S5 seam. It must establish App authorization, native ACL,
-// grant-owner/scope continuity and a server-issued single-use ticket bound to
-// the COMPLETE decoded control and actor/session. It is not installed by S3;
-// nil always refuses work. No caller continuity/actor/admin fields are accepted.
-type GrantOperationValidator interface {
-	ValidateOperation(context.Context, NativeActor, DataRequest, Grant) (GrantUseValidation, Code)
-}
-
-type GrantUseValidation struct {
-	Binding    ContinuityBinding
-	Continuous bool
-	Ticket     TicketBinding
-	root       readOnlyRootWitness // trusted in-memory epoch pin; never caller JSON
-}
-
-// Fixed internal supervisor services. There is no package/plugin injection or
-// caller executable. S3 production leaves unproved native/ACL adapters nil.
-type supervisorGrantServices struct {
-	writes       writeGates
-	writeIntents writeIntentStore
-	native       *NativeProvider
-	consent      ConsentValidator
-	operations   GrantOperationValidator
-	output       func(operationBinding) (net.Conn, Code)
-}
-
-// GrantDrainProof is S2's bounded receipt for one grant. Reaped counts require
-// actual owned-child Wait4 AND stopped relay/closed private descriptors. Bytes
-// count admitted effects; they do not assert rollback or bytes already sent.
-type GrantDrainProof struct {
-	Key                 GrantDrainKey `json:"key"`
-	Started             uint64        `json:"started"`
-	Reaped              uint64        `json:"reaped"`
-	WriteOperations     uint64        `json:"writeOperations,omitempty"`
-	BytesWritten        uint64        `json:"bytesWritten,omitempty"`
-	WriteEffectsUnknown bool          `json:"writeEffectsUnknown,omitempty"`
-	PublishedOperations uint64        `json:"publishedOperations,omitempty"`
-	CommittedOperations uint64        `json:"committedOperations,omitempty"`
-	AdmittedBytes       uint64        `json:"admittedBytes"`
-}