diff --git a/AGENTS.md b/AGENTS.md index 140a0bc89e..3892765082 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -18,7 +18,7 @@ This document contains rules and conventions for AI agents working on this codeb **Volume preload is load-bearing for the `LedgerLog.new_kept_volumes` / `ephemeral_volumes` split.** Admission MUST preload the current value of every `(account, asset)` volume touched by an order, including postings resolved from numscript execution. The FSM classifies a volume as "newly created" by checking `Old.IsDefined()` (or the zero-placeholder via `isVolumePreloadZero`) at merge time — a silent cache miss on an existing volume produces a false-new classification, mis-routes the tuple between the `new_kept_volumes` / `ephemeral_volumes` / `purged_volumes` per-log lists, and inflates `usagestore.CounterVolume`. Because `usagestore` is a rebuildable peer side-store held **outside** checker scope (invariant #8 verifies only primary-Pebble-store projections), no checker pass would surface the drift; it persists until an explicit usage rebuild. That absence of a backstop makes the preload correctness even more load-bearing, not less. This is not opportunistic (unlike the metadata preload that was removed after the indexbuilder stopped needing it): balance checks, Uint256 arithmetic and numscript resolution all require the current volume value, so the preload is structurally mandatory. If a future refactor considers alleviating volume preload, `VolumeCount` must be re-hosted first (via computed-on-read or a subsystem-side seen-keys table) — see EN-1422 for the design rationale. 7. **Never silently skip a "should not happen" branch** — A branch that is reachable only if an invariant is violated (nil where the contract says non-nil, a state we believe unreachable, a cache miss after a guaranteed preload, etc.) MUST surface a loud signal: `return fmt.Errorf("invariant: ...")` so it bubbles up, or `assert.Unreachable(...)` for SUT-level invariants exercised under antithesis. A silent `return nil` / `continue` on these branches hides real bugs — particularly catastrophic in the FSM apply path, where a no-op desyncs nodes from each other. Branches that represent genuine runtime conditions (cache miss as an expected outcome, stale proposal, deleted entity) keep their soft `return nil`. The distinction is whether the case is *expected* (soft skip OK) or *impossible by design* (must fail loudly). The comment must say *why* the case is impossible so a reader can decide whether to add a hard fail or relax the rule. -8. **The audit log is the only source of truth — every other persisted dataset is a projection and must be verified by the checker** — Only `AuditEntry` (zone `Cold`, sub `Audit`) is cryptographically bound, via the hash chain that `state.BuildHashedHeaderPayload` + `processing.HashGenerator` produce and `checker.verifyAuditHashChain` verifies on every Check() run. Everything else stored in Pebble — `Log`, `AuditItem`, `AppliedProposal`, `LedgerLog.PurgedVolumes`, attribute caches (`Volume`, `Metadata`, `Transaction`, `Reference`, `Boundary`, etc.), reversion bitsets, idempotency keys, mirror cursors, chapters, bloom filters, signing keys, the read-side index — is a *projection* of orders that already live in the audit chain. Projections are rebuildable from the audit on demand, so we deliberately do NOT extend the hash chain to cover them (refactor over hash binding — see `feedback_audit_is_source_of_truth`). In exchange, **`internal/application/check/checker.go` MUST verify every projection it persists**: re-derive the value the projection should hold by replaying the audit (`ReplayLedgerLog`, `SimulateEphemeralPurge`, `partitionVolumes`, etc.) and compare to what is stored, emitting the matching `CHECK_STORE_ERROR_TYPE_*` event on divergence. A projection that the checker does not verify is a tampering vector — adding a new persisted projection without a matching compare* / collect* pass in the checker is the violation. Two scope refinements: (a) this applies to the **primary FSM store** — the single store `Check()` opens and walks; **peer secondary stores** (the `readstore` inverted index today; the `usagestore` counters forthcoming with EN-1334) are out of *main-store checker* scope *by construction* since `Check()` never opens them. That scope carve-out is **not** a claim they are integrity-safe: the readstore serves READY indexes directly to business-visible queries with no scan fallback, and its automated detect/drop/rebuild is **not yet wired** (tracked under `EN-1323`), so a corrupted or tampered index is a **current open integrity gap on the peer-store side** — a per-replica rebuild-health concern of the index builder, not an invariant-#8 main-store concern. Out of the main-store checker's mandate, not out of every integrity concern. (b) A primary-store projection may be exempted from a dedicated pass only when it is either (i) deterministically rebuildable from still-retained verified state through a real, *wired* rebuild path — not rebuildable merely in principle — or (ii) purely informational and intentionally carried across restore (cf. `BuildStatus`). These are distinct bases: of the *Known projection gaps* below, `DefaultEnforcementMode` and `SubAttrLedgerMetadata` qualify under (i) via `RebuildDelta` (`BuildStatus` on the index registry is the canonical (ii) example). The current passes are `compareVolumes`, `compareMetadata`, `compareTransactions`, `compareExclusionProjections` (AppliedProposal.TransientVolumes + LedgerLog.PurgedVolumes), `checkReversionInvariants`, `verifySealingHash`, `compareIdempotencyOutcomes` (frozen idempotency outcomes in SubIdempKeys vs the hash-chained AuditFailure/AuditSuccess that wrote them — the failure kind is re-derived from the chain-bound reason via `domain.KindForReason`, never stored), and `compareIndexes` (SubAttrIndex registry vs CreateIndex/DropIndex/RemovedMetadataFieldType/DeleteLedger logs — covers presence + identity; BuildStatus is intentionally excluded because it is purely informational on the cluster-wide registry entry — queries gate on the per-replica `IndexVersionState.CurrentVersion`, not on BuildStatus), and `compareMirrorV2LogID` (stored `LedgerBoundaries.last_mirror_v2_log_id` **==** `max(audited MirrorIngest.v2_log_id)` per ledger — a full equality check, `CHECK_STORE_ERROR_TYPE_MIRROR_V2LOGID_MISMATCH` on ANY divergence; the FSM enforces a contiguous applied prefix so at rest the two must be exactly equal, and the baseline floor is seeded from archived `Boundary` rows now included in the compact baseline snapshot; pre-field clusters are unsupported, no backfill leniency), and `compareSchema` (per-ledger `LedgerInfo.MetadataSchema` vs the replayed CreateLedger.initial_schema + SetMetadataFieldType/RemovedMetadataFieldType logs; under archived chapters the boundary schema is seeded from the baseline checkpoint, which carries LedgerInfo for this purpose), and `compareAccountTypes` (per-ledger `LedgerInfo.AccountTypes` vs the replayed AddAccountType/RemoveAccountType logs, baseline-seeded under archiving like the schema), and `compareLedgerPresence` (the live ledger set in the store must match the audit-derived set both ways: every audit-live ledger — CreateLedger with no later DeleteLedger, or a non-deleted baseline ledger under archiving — must have a *live* stored `LedgerInfo` else `MISSING_LEDGER` (covers an entry deleted outright OR tampered to a soft-deleted tombstone, which the compareSchema/compareAccountTypes loops skip), and every live stored `LedgerInfo` must be audit-backed else `UNAUDITED_LEDGER` (an injected empty ledger row carries no schema/types for the projection passes to flag). The audit-derived set is NEVER seeded from the live store — under archiving it comes from the baseline checkpoint, keeping the check independent of the data it verifies), and `compareReferences` (the SubAttrReference reference→txID uniqueness index vs the references replayed from CreatedTransaction/RevertedTransaction logs, baseline-seeded under archiving; verified both ways — missing, unaudited, and retargeted rows are all flagged; rows for deleted or cleanup-pending ledgers are skipped since they legitimately linger until a covering purge runs deleteLedgerData), and `compareBoundaries` (per-ledger `LedgerBoundaries` vs the checker’s re-derivation: only NextTransactionId/NextLogId are verified here — derived from the replayed logs plus the chain-bound AuditItem order effects (mirror fill-gap advances live on the orders, not the ledger-log stream), baseline-seeded under archiving; the mirror high-water `last_mirror_v2_log_id` is verified separately by `compareMirrorV2LogID`. The per-ledger usage counters — `PostingCount`, `RevertCount`, `NumscriptExecutionCount`, `VolumeCount`, `MetadataCount`, `ReferenceCount`, `EphemeralEvictedCount`, `TransientUsedCount` — no longer live on `LedgerBoundaries`: `LedgerBoundaries` now reserves tags 3-10 for them and they moved to the `usagestore` peer secondary store (EN-1334 / EN-1420), out of main-store checker scope **by construction** (per the peer-store carve-out in scope refinement (a) above), their integrity being a peer-store rebuild-health concern — reconverged by the online usagebuilder fold + `usagestore.Reset()` on rollback — rather than an invariant-#8 main-store concern), and `compareReversions` (the per-ledger reversion bitsets — `ZonePerLedger`/`SubPLReversions`, the projection the FSM's already-reverted gate reads — vs the reverted set derived from baseline tx-row markers plus the replayed RevertedTransaction logs; exact equality both ways — a lost bit re-admits a double revert, an unaudited bit blocks a legitimate one; driven purely by audit-derived state — no persisted marker (pending-cleanup included) can exempt a live ledger, stored rows for non-live ledgers are flagged since DeleteLedger deletes them at apply on both the live path and the replay, and undecodable rows are reported); extend the list as new persisted projections land. **Known projection gaps**: `LedgerInfo.DefaultEnforcementMode` and the ledger-metadata attribute (`SubAttrLedgerMetadata`) have no compare pass yet (both are rebuilt on restore by RebuildDelta). +8. **The audit log is the only source of truth — every other persisted dataset is a projection and must be verified by the checker** — Only `AuditEntry` (zone `Cold`, sub `Audit`) is cryptographically bound, via the hash chain that `state.BuildHashedHeaderPayload` + `processing.HashGenerator` produce and `checker.verifyAuditHashChain` verifies on every Check() run. Everything else stored in Pebble — `Log`, `AuditItem`, `AppliedProposal`, `LedgerLog.PurgedVolumes`, attribute caches (`Volume`, `Metadata`, `Transaction`, `Reference`, `Boundary`, etc.), reversion bitsets, idempotency keys, mirror cursors, chapters, bloom filters, signing keys, the read-side index — is a *projection* of orders that already live in the audit chain. Projections are rebuildable from the audit on demand, so we deliberately do NOT extend the hash chain to cover them (refactor over hash binding — see `feedback_audit_is_source_of_truth`). In exchange, **`internal/application/check/checker.go` MUST verify every projection it persists**: re-derive the value the projection should hold by replaying the audit (`ReplayLedgerLog`, `SimulateEphemeralPurge`, `partitionVolumes`, etc.) and compare to what is stored, emitting the matching `CHECK_STORE_ERROR_TYPE_*` event on divergence. A projection that the checker does not verify is a tampering vector — adding a new persisted projection without a matching compare* / collect* pass in the checker is the violation. Two scope refinements: (a) this applies to the **primary FSM store** — the single store `Check()` opens and walks; **peer secondary stores** (the `readstore` inverted index today; the `usagestore` counters forthcoming with EN-1334) are out of *main-store checker* scope *by construction* since `Check()` never opens them. That scope carve-out is **not** a claim they are integrity-safe: the readstore serves READY indexes directly to business-visible queries with no scan fallback, and its automated detect/drop/rebuild is **not yet wired** (tracked under `EN-1323`), so a corrupted or tampered index is a **current open integrity gap on the peer-store side** — a per-replica rebuild-health concern of the index builder, not an invariant-#8 main-store concern. Out of the main-store checker's mandate, not out of every integrity concern. (b) A primary-store projection may be exempted from a dedicated pass only when it is either (i) deterministically rebuildable from still-retained verified state through a real, *wired* rebuild path — not rebuildable merely in principle — or (ii) purely informational and intentionally carried across restore (cf. `BuildStatus`). These are distinct bases: of the *Known projection gaps* below, `DefaultEnforcementMode` and `SubAttrLedgerMetadata` qualify under (i) via `RebuildDelta` (`BuildStatus` on the index registry is the canonical (ii) example). The current passes are `compareVolumes`, `compareMetadata`, `compareTransactions`, `compareExclusionProjections` (AppliedProposal.TransientVolumes + LedgerLog.PurgedVolumes), `checkReversionInvariants`, `verifySealingHash`, `compareIdempotencyOutcomes` (frozen idempotency outcomes in SubIdempKeys vs the hash-chained AuditFailure/AuditSuccess that wrote them — the failure kind is re-derived from the chain-bound reason via `domain.KindForReason`, never stored), and `compareIndexes` (SubAttrIndex registry vs CreateIndex/DropIndex/RemovedMetadataFieldType/DeleteLedger logs — covers presence + identity; BuildStatus is intentionally excluded because it is purely informational on the cluster-wide registry entry — queries gate on the per-replica `IndexVersionState.CurrentVersion`, not on BuildStatus), and `compareMirrorV2LogID` (stored `LedgerBoundaries.last_mirror_v2_log_id` **==** `max(audited MirrorIngest.v2_log_id)` per ledger — a full equality check, `CHECK_STORE_ERROR_TYPE_MIRROR_V2LOGID_MISMATCH` on ANY divergence; the FSM enforces a contiguous applied prefix so at rest the two must be exactly equal, and the baseline floor is seeded from archived `Boundary` rows now included in the compact baseline snapshot; pre-field clusters are unsupported, no backfill leniency), and `compareSchema` (per-ledger `LedgerInfo.MetadataSchema` vs the replayed CreateLedger.initial_schema + SetMetadataFieldType/RemovedMetadataFieldType logs; under archived chapters the boundary schema is seeded from the baseline checkpoint, which carries LedgerInfo for this purpose), and `compareAccountTypes` (per-ledger `LedgerInfo.AccountTypes` vs the replayed AddAccountType/RemoveAccountType logs, baseline-seeded under archiving like the schema), and `compareLedgerPresence` (the live ledger set in the store must match the audit-derived set both ways: every audit-live ledger — CreateLedger with no later DeleteLedger, or a non-deleted baseline ledger under archiving — must have a *live* stored `LedgerInfo` else `MISSING_LEDGER` (covers an entry deleted outright OR tampered to a soft-deleted tombstone, which the compareSchema/compareAccountTypes loops skip), and every live stored `LedgerInfo` must be audit-backed else `UNAUDITED_LEDGER` (an injected empty ledger row carries no schema/types for the projection passes to flag). The audit-derived set is NEVER seeded from the live store — under archiving it comes from the baseline checkpoint, keeping the check independent of the data it verifies), and `compareReferences` (the SubAttrReference reference→txID uniqueness index vs the references replayed from CreatedTransaction/RevertedTransaction logs, baseline-seeded under archiving; verified both ways — missing, unaudited, and retargeted rows are all flagged; rows for deleted or cleanup-pending ledgers are skipped since they legitimately linger until a covering purge runs deleteLedgerData), and `compareBoundaries` (per-ledger `LedgerBoundaries` vs the checker’s re-derivation: only NextTransactionId/NextLogId are verified here — derived from the replayed logs plus the chain-bound AuditItem order effects (mirror fill-gap advances live on the orders, not the ledger-log stream), baseline-seeded under archiving; the mirror high-water `last_mirror_v2_log_id` is verified separately by `compareMirrorV2LogID`. The per-ledger usage counters — `PostingCount`, `RevertCount`, `NumscriptExecutionCount`, `VolumeCount`, `MetadataCount`, `ReferenceCount`, `EphemeralEvictedCount`, `TransientUsedCount` — no longer live on `LedgerBoundaries`: `LedgerBoundaries` now reserves tags 3-10 for them and they moved to the `usagestore` peer secondary store (EN-1334 / EN-1420), out of main-store checker scope **by construction** (per the peer-store carve-out in scope refinement (a) above), their integrity being a peer-store rebuild-health concern — reconverged by the online usagebuilder fold + `usagestore.Reset()` on rollback — rather than an invariant-#8 main-store concern), and `compareReversions` (the per-ledger reversion bitsets — `ZonePerLedger`/`SubPLReversions`, the projection the FSM's already-reverted gate reads — vs the reverted set derived from baseline tx-row markers plus the replayed RevertedTransaction logs; exact equality both ways — a lost bit re-admits a double revert, an unaudited bit blocks a legitimate one; driven purely by audit-derived state — no persisted marker (pending-cleanup included) can exempt a live ledger, stored rows for non-live ledgers are flagged since DeleteLedger deletes them at apply on both the live path and the replay, and undecodable rows are reported), and `compareNumscripts` (SubAttrNumscriptContent immutable version entries + SubAttrNumscriptVersion latest pointers vs SavedNumscript/DeleteLedger logs — a save writes immutable content and advances the latest pointer to the greatest stored semver; catches altered/missing/extra content and a latest pointer that is not the greatest saved semver; baseline-seeded under archiving so surplus/injected rows are flagged, no archive-orphan tolerance); extend the list as new persisted projections land. **Known projection gaps**: `LedgerInfo.DefaultEnforcementMode` and the ledger-metadata attribute (`SubAttrLedgerMetadata`) have no compare pass yet (both are rebuilt on restore by RebuildDelta). 9. **Never bypass the FSM coverage gate** — Every cache-attribute read on the FSM hot path MUST go through `Scope.GetX(...)` so the per-order `coverage_bits` admit it. Reading the underlying `Registry.X.KeyStore().M` (or any other parent-cache iterator) directly skips the gate and produces non-deterministic FSM behavior: the gate is what binds the order to the admission-declared preload set, and a direct read silently sees keys the proposer never declared. There is NO documented exception — paths that need to iterate (e.g. cascade-on-delete) MUST either declare the relevant `preload.Needs` upfront, defer the work to a lifecycle path (`batch.deleteLedgerData` + `MarkLedgerForCleanup`), or be rejected at design review. New helpers that scan the parent KeyStore from inside an order/TU handler are the violation, even when wrapped in a method on `WriteSet`. The coverage gate exists precisely so admission's declared key set is the FSM's only legitimate read horizon — under no circumstances should the apply path widen it on the fly. diff --git a/cmd/ledgerctl/ledgers/config_model.go b/cmd/ledgerctl/ledgers/config_model.go index 3029b9b453..71820e7c1b 100644 --- a/cmd/ledgerctl/ledgers/config_model.go +++ b/cmd/ledgerctl/ledgers/config_model.go @@ -12,6 +12,7 @@ import ( "github.com/formancehq/ledger/v3/cmd/ledgerctl/accounttypes" "github.com/formancehq/ledger/v3/internal/pkg/filterexpr" + "github.com/formancehq/ledger/v3/internal/pkg/semver" "github.com/formancehq/ledger/v3/internal/proto/commonpb" "github.com/formancehq/ledger/v3/internal/proto/servicepb" ) @@ -269,7 +270,11 @@ func ComputeDiff(ledgerName string, current, desired *EditableConfig) ([]DiffAct } actions = append(actions, pqActions...) - actions = append(actions, diffNumscripts(ledgerName, current, desired)...) + nsActions, err := diffNumscripts(ledgerName, current, desired) + if err != nil { + return nil, err + } + actions = append(actions, nsActions...) return actions, nil } @@ -744,63 +749,80 @@ func diffPreparedQueries(ledgerName string, current, desired *EditableConfig) ([ return actions, nil } -func diffNumscripts(ledgerName string, current, desired *EditableConfig) []DiffAction { +func diffNumscripts(ledgerName string, current, desired *EditableConfig) ([]DiffAction, error) { var actions []DiffAction - // Added or updated + // The library is immutable and append-only: a save is only ever a NEW + // version. Editing a version's content in place is impossible server-side, + // so an edit that keeps the same version is a mistake — catch it here + // rather than emitting a save the server rejects with + // NUMSCRIPT_VERSION_ALREADY_EXISTS. for name, desiredNS := range desired.Numscripts { currentNS, exists := current.Numscripts[name] - if !exists || currentNS.Content != desiredNS.Content || currentNS.Version != desiredNS.Version { - op := "add" - desc := fmt.Sprintf("Save numscript %q", name) - if desiredNS.Version != "" { - desc += fmt.Sprintf(" (v%s)", desiredNS.Version) + + if exists && currentNS.Version == desiredNS.Version { + if currentNS.Content != desiredNS.Content { + return nil, fmt.Errorf("numscript %q: content changed but version %q was not bumped; publish the change under a new semver", name, desiredNS.Version) } - if exists { - op = "update" - desc = fmt.Sprintf("Update numscript %q", name) - if desiredNS.Version != "" { - desc += fmt.Sprintf(" (v%s)", desiredNS.Version) - } + + continue + } + + // The server requires an explicit full canonical semver; validate here + // so an omitted/partial/non-canonical version fails the diff with a + // clear message rather than a valid-looking plan that only errors at + // apply time. + desiredVersion, err := semver.Parse(desiredNS.Version) + if err != nil { + return nil, fmt.Errorf("numscript %q: %w (a full canonical semver is required, e.g. 1.0.0)", name, err) + } + + // The exported config carries only the greatest version of each script, + // and latest is always the greatest stored semver. A desired version at + // or below the current greatest can never become latest, so the plan + // would never converge (and re-fail with NUMSCRIPT_VERSION_ALREADY_EXISTS + // once stored). Require a strictly greater version to advance latest. + if exists { + currentVersion, err := semver.Parse(currentNS.Version) + if err != nil { + return nil, fmt.Errorf("numscript %q: stored version %q is not a canonical semver: %w", name, currentNS.Version, err) } - actions = append(actions, DiffAction{ - Section: "numscript", - Operation: op, - Description: desc, - Request: &servicepb.Request{ - Type: &servicepb.Request_SaveNumscript{ - SaveNumscript: &servicepb.SaveNumscriptRequest{ - Ledger: ledgerName, - Name: name, - Content: desiredNS.Content, - Version: desiredNS.Version, - }, + + if desiredVersion.Compare(currentVersion) <= 0 { + return nil, fmt.Errorf("numscript %q: desired version %q is not greater than the current greatest %q; publish a higher version to advance latest", name, desiredNS.Version, currentNS.Version) + } + } + + desc := fmt.Sprintf("Save numscript %q (v%s)", name, desiredNS.Version) + + actions = append(actions, DiffAction{ + Section: "numscript", + Operation: "add", + Description: desc, + Request: &servicepb.Request{ + Type: &servicepb.Request_SaveNumscript{ + SaveNumscript: &servicepb.SaveNumscriptRequest{ + Ledger: ledgerName, + Name: name, + Content: desiredNS.Content, + Version: desiredNS.Version, }, }, - }) - } + }, + }) } - // Removed + // The library is append-only: a script present in the store but dropped + // from the desired config cannot be removed, so the desired state is + // unreachable. Fail loudly rather than silently reporting "already up to + // date" (the other config sections emit a remove action here). for name := range current.Numscripts { - if _, exists := desired.Numscripts[name]; !exists { - actions = append(actions, DiffAction{ - Section: "numscript", - Operation: "remove", - Description: fmt.Sprintf("Delete numscript %q", name), - Request: &servicepb.Request{ - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Ledger: ledgerName, - Name: name, - }, - }, - }, - }) + if _, ok := desired.Numscripts[name]; !ok { + return nil, fmt.Errorf("numscript %q exists in the ledger but is absent from the desired config; the append-only library does not support removal", name) } } - return actions + return actions, nil } func parseEnforcementModeProto(s string) commonpb.ChartEnforcementMode { diff --git a/cmd/ledgerctl/numscripts/command.go b/cmd/ledgerctl/numscripts/command.go index 30c2939c07..363e45546b 100644 --- a/cmd/ledgerctl/numscripts/command.go +++ b/cmd/ledgerctl/numscripts/command.go @@ -7,7 +7,7 @@ func NewCommand() *cobra.Command { Use: "numscripts", Aliases: []string{"numscript", "ns"}, Short: "Manage numscript library", - Long: "Commands for managing the per-ledger numscript library (save, get, list, delete)", + Long: "Commands for managing the per-ledger numscript library (save, get, list, versions)", } cmd.PersistentFlags().String("ledger", "", "Ledger name (interactive selection if omitted)") @@ -15,7 +15,7 @@ func NewCommand() *cobra.Command { cmd.AddCommand(NewSaveCommand()) cmd.AddCommand(NewGetCommand()) cmd.AddCommand(NewListCommand()) - cmd.AddCommand(NewDeleteCommand()) + cmd.AddCommand(NewVersionsCommand()) return cmd } diff --git a/cmd/ledgerctl/numscripts/delete.go b/cmd/ledgerctl/numscripts/delete.go deleted file mode 100644 index 736bc0a7fc..0000000000 --- a/cmd/ledgerctl/numscripts/delete.go +++ /dev/null @@ -1,87 +0,0 @@ -package numscripts - -import ( - "fmt" - - "github.com/pterm/pterm" - "github.com/spf13/cobra" - - "github.com/formancehq/ledger/v3/cmd/ledgerctl/cmdutil" - "github.com/formancehq/ledger/v3/internal/proto/servicepb" -) - -// NewDeleteCommand creates the numscripts delete command. -func NewDeleteCommand() *cobra.Command { - cmd := &cobra.Command{ - Use: "delete ", - Aliases: []string{"rm", "remove"}, - Short: "Delete a numscript from the library", - Long: `Delete a numscript from a ledger's library. - -This removes the latest version pointer. Historical versions are preserved. - -Examples: - ledgerctl numscripts delete transfer --ledger myledger`, - Args: cobra.ExactArgs(1), - ValidArgsFunction: cobra.NoFileCompletions, - RunE: runDelete, - } - - cmd.Flags().Duration("timeout", cmdutil.DefaultTimeout, "Request timeout") - - return cmd -} - -func runDelete(cmd *cobra.Command, args []string) error { - name := args[0] - - client, conn, err := cmdutil.GetClient(cmd) - if err != nil { - return err - } - - defer func() { _ = conn.Close() }() - - ledgerFlag, _ := cmd.Flags().GetString("ledger") - ledgerName, err := cmdutil.SelectLedger(cmd, client, ledgerFlag) - if err != nil { - return err - } - - ctx, cancel := cmdutil.GetContext(cmd) - defer cancel() - - spinner, _ := pterm.DefaultSpinner.Start(fmt.Sprintf("Deleting numscript %s...", name)) - - requests := []*servicepb.Request{ - { - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Ledger: ledgerName, - Name: name, - }, - }, - }, - } - - applyReq, err := cmdutil.BuildApplyRequest(cmd, requests...) - if err != nil { - spinner.Fail("Failed to sign request") - - return cmdutil.Displayed(err) - } - - _, err = client.Apply(ctx, applyReq) - if err != nil { - _ = spinner.Stop() - - return cmdutil.FormatGRPCError("failed to delete numscript", err) - } - - spinner.Success("Deleted") - - pterm.Println() - pterm.Printf("Numscript: %s (deleted from %s)\n", pterm.Gray(name), pterm.Cyan(ledgerName)) - - return nil -} diff --git a/cmd/ledgerctl/numscripts/list.go b/cmd/ledgerctl/numscripts/list.go index 37ca47d392..fd2aeb9389 100644 --- a/cmd/ledgerctl/numscripts/list.go +++ b/cmd/ledgerctl/numscripts/list.go @@ -92,7 +92,7 @@ func runList(cmd *cobra.Command, _ []string) error { if len(scripts) == 0 { pterm.Info.Printfln("No numscripts in library for ledger %s.", ledgerName) pterm.Println(pterm.Gray("Hint: Save a numscript using:")) - pterm.FgCyan.Printfln(" ledgerctl numscripts save --ledger %s --file ", ledgerName) + pterm.FgCyan.Printfln(" ledgerctl numscripts save --ledger %s --file --version 1.0.0", ledgerName) return nil } diff --git a/cmd/ledgerctl/numscripts/save.go b/cmd/ledgerctl/numscripts/save.go index 5986ccfe27..404b2014a4 100644 --- a/cmd/ledgerctl/numscripts/save.go +++ b/cmd/ledgerctl/numscripts/save.go @@ -17,22 +17,23 @@ func NewSaveCommand() *cobra.Command { cmd := &cobra.Command{ Use: "save ", Short: "Save a numscript to the library", - Long: `Save a numscript to a ledger's library. + Long: `Save a new immutable version of a numscript to a ledger's library. -If a script with the same name already exists, a new version is created. -The script content is read from a file (--file) or stdin. +The library is append-only: the version must be an explicit full semver and +must not already exist. The script content is read from a file (--file) or stdin. Examples: - ledgerctl numscripts save transfer --ledger myledger --file transfer.num - cat transfer.num | ledgerctl numscripts save transfer --ledger myledger`, + ledgerctl numscripts save transfer --ledger myledger --file transfer.num --version 1.0.0 + cat transfer.num | ledgerctl numscripts save transfer --ledger myledger --version 1.0.0`, Args: cobra.ExactArgs(1), ValidArgsFunction: cobra.NoFileCompletions, RunE: runSave, } cmd.Flags().String("file", "", "Path to the numscript file (reads stdin if omitted)") - cmd.Flags().String("version", "", "Semver version (e.g. 1.0.0) or empty for latest") + cmd.Flags().String("version", "", "Explicit full semver (e.g. 1.0.0); required") cmd.Flags().Duration("timeout", cmdutil.DefaultTimeout, "Request timeout") + _ = cmd.MarkFlagRequired("version") return cmd } diff --git a/cmd/ledgerctl/numscripts/versions.go b/cmd/ledgerctl/numscripts/versions.go new file mode 100644 index 0000000000..a4706e063b --- /dev/null +++ b/cmd/ledgerctl/numscripts/versions.go @@ -0,0 +1,98 @@ +package numscripts + +import ( + "github.com/pterm/pterm" + "github.com/spf13/cobra" + + "github.com/formancehq/ledger/v3/cmd/ledgerctl/cmdutil" + "github.com/formancehq/ledger/v3/internal/proto/servicepb" +) + +// NewVersionsCommand creates the numscripts versions command. +func NewVersionsCommand() *cobra.Command { + cmd := &cobra.Command{ + Use: "versions ", + Short: "List every stored version of a numscript", + Long: `List the current latest version (the greatest stored semver) and every +stored version of a numscript, highest semver first. + +Examples: + ledgerctl numscripts versions transfer --ledger myledger`, + Args: cobra.ExactArgs(1), + ValidArgsFunction: cobra.NoFileCompletions, + RunE: runVersions, + } + + cmdutil.AddConsistencyFlags(cmd) + cmdutil.AddOutputFlags(cmd) + cmd.Flags().Duration("timeout", cmdutil.DefaultTimeout, "Request timeout") + + return cmd +} + +func runVersions(cmd *cobra.Command, args []string) error { + name := args[0] + + client, conn, err := cmdutil.GetClient(cmd) + if err != nil { + return err + } + + defer func() { _ = conn.Close() }() + + ledgerFlag, _ := cmd.Flags().GetString("ledger") + ledgerName, err := cmdutil.SelectLedger(cmd, client, ledgerFlag) + if err != nil { + return err + } + + ctx, cancel := cmdutil.GetContext(cmd) + defer cancel() + + resp, err := client.ListNumscriptVersions(ctx, &servicepb.ListNumscriptVersionsRequest{ + Ledger: ledgerName, + Name: name, + Read: cmdutil.BuildReadOptions(cmdutil.GetConsistencyFlags(cmd)), + }) + if err != nil { + return cmdutil.FormatGRPCError("failed to list numscript versions", err) + } + + versions := resp.GetVersions() + + if handled, err := cmdutil.EncodeStructured(cmd, resp); handled || err != nil { + return err + } + + if len(versions) == 0 { + pterm.Info.Printfln("No versions stored for numscript %s on ledger %s.", name, ledgerName) + + return nil + } + + pterm.Printf("Latest: %s\n\n", pterm.Cyan(resp.GetLatestVersion())) + + tableData := pterm.TableData{ + {"VERSION", "CREATED AT"}, + } + + for _, v := range versions { + createdAt := "" + if v.GetCreatedAt() != nil { + createdAt = v.GetCreatedAt().AsTime().Format("2006-01-02T15:04:05Z07:00") + } + + tableData = append(tableData, []string{ + v.GetVersion(), + createdAt, + }) + } + + if err := pterm.DefaultTable.WithHasHeader().WithData(tableData).Render(); err != nil { + return err + } + + pterm.Println() + + return nil +} diff --git a/docs/ops/cli.md b/docs/ops/cli.md index 204a024ef1..547b49cd7a 100644 --- a/docs/ops/cli.md +++ b/docs/ops/cli.md @@ -3533,6 +3533,26 @@ ledgerctl numscripts list --ledger [flags] |------|---------|-------------| | `--timeout` | `10s` | Request timeout | +#### numscripts versions + +List every stored version of a numscript, highest semver first, alongside the current latest pointer (the greatest stored semver). + +```bash +ledgerctl numscripts versions --ledger [flags] +``` + +**Flags:** + +| Flag | Default | Description | +|------|---------|-------------| +| `--timeout` | `10s` | Request timeout | + +**Example:** + +```bash +ledgerctl numscripts versions transfer --ledger myledger +``` + #### numscripts get Get a numscript from the library by name. @@ -3545,13 +3565,13 @@ ledgerctl numscripts get --ledger [flags] | Flag | Default | Description | |------|---------|-------------| -| `--version` | | Specific version to retrieve (empty = latest) | +| `--version` | | Version selector (exact semver, or empty/`latest` for the greatest stored semver) | | `--timeout` | `10s` | Request timeout | **Example:** ```bash -# Get the latest version +# Get the latest version (greatest stored semver) ledgerctl numscripts get transfer --ledger myledger # Get a specific version @@ -3560,10 +3580,10 @@ ledgerctl numscripts get transfer --ledger myledger --version 1.0.0 #### numscripts save -Save a numscript to a ledger's library. If a script with the same name already exists, a new version is created. +Save a new immutable version of a numscript. The version must be an explicit full semver and must not already exist. The library is append-only: existing versions are never overwritten, and the latest pointer advances to the greatest stored semver. ```bash -ledgerctl numscripts save --ledger [flags] +ledgerctl numscripts save --ledger --version [flags] ``` **Flags:** @@ -3571,38 +3591,22 @@ ledgerctl numscripts save --ledger [flags] | Flag | Default | Description | |------|---------|-------------| | `--file` | | Path to the numscript file (reads stdin if omitted) | -| `--version` | | Semver version (e.g. `1.0.0`) or empty for latest | +| `--version` | | Explicit full semver (e.g. `1.0.0`); required | | `--timeout` | `10s` | Request timeout | **Example:** ```bash # Save from a file -ledgerctl numscripts save transfer --ledger myledger --file transfer.num +ledgerctl numscripts save transfer --ledger myledger --file transfer.num --version 1.0.0 -# Save with a specific version +# Save a later version ledgerctl numscripts save transfer --ledger myledger --file transfer.num --version 2.0.0 # Save from stdin -cat transfer.num | ledgerctl numscripts save transfer --ledger myledger -``` - -#### numscripts delete - -Delete a numscript from the library. - -**Aliases:** `rm`, `remove` - -```bash -ledgerctl numscripts delete --ledger [flags] +cat transfer.num | ledgerctl numscripts save transfer --ledger myledger --version 1.0.0 ``` -**Flags:** - -| Flag | Default | Description | -|------|---------|-------------| -| `--timeout` | `10s` | Request timeout | - --- ### queries diff --git a/docs/technical/architecture/subsystems/checker/checker.md b/docs/technical/architecture/subsystems/checker/checker.md index 05c6798ce0..927a78e263 100644 --- a/docs/technical/architecture/subsystems/checker/checker.md +++ b/docs/technical/architecture/subsystems/checker/checker.md @@ -42,10 +42,12 @@ Each pass takes a persisted projection, re-derives the expected value by replayi | 9 | `compareIndexes` | `SubAttrIndex` registry matches the set derived from `CreateIndex` / `DropIndex` / `RemovedMetadataFieldType` / `DeleteLedger` logs (presence + identity only) | Replay of the index-affecting log types | `INDEX_MISMATCH` | | 10 | `compareMirrorV2LogID` | Stored `LedgerBoundaries.last_mirror_v2_log_id` **equals** the max audited `MirrorIngest.v2_log_id` per ledger (full equality) | Live audit chain (`recordMirrorIngestMutations`) over a baseline floor (`foldBaselineBoundaries`) | `MIRROR_V2LOGID_MISMATCH` (any divergence) | | 11 | `compareReversions` | Stored reversion bitsets (`ZonePerLedger`/`SubPLReversions`, the rows the already-reverted gate reads) equal the audit-derived reverted set, both ways; stored rows for non-live ledgers and undecodable rows are flagged | Baseline tx-row markers + replayed `RevertedTransaction` logs | `REVERTED_MISMATCH` | +| 12 | `compareNumscripts` | `SubAttrNumscriptContent` immutable version entries and `SubAttrNumscriptVersion` latest pointers (the greatest stored semver) match the saved versions | Replay of `SavedNumscript` / `DeleteLedger` logs | `NUMSCRIPT_MISMATCH` | Notes: - **`compareIndexes` covers presence + identity** (`IndexID` match), **not `BuildStatus`** and **not `IndexVersionState`**. `BuildStatus` is informational and per-replica; `IndexVersionState` is by design local and may legitimately differ across nodes mid-rewrite (see [indexer / indexes.md](../indexer/indexes.md)). +- **`compareNumscripts`** re-derives both numscript projections from the audit chain. The library is immutable and append-only: a `SavedNumscript` writes an immutable content entry and advances the per-name latest pointer to the greatest stored semver (versions may be saved out of order). It catches altered/missing/extra content and a latest pointer that is not the greatest saved semver. Unlike `compareIndexes`, the expected state is baseline-seeded under archiving (`foldBaselineNumscripts`), so there is no archive-orphan tolerance — a stored row absent from both baseline and replay is flagged as surplus; only the deferred-cleanup (pending-purge) tolerance remains. - **`compareIdempotencyOutcomes`** is the one pass that consumes a side-effect of `verifyAuditHashChain` (the expected-outcome map). The two are coupled by design — re-deriving the idempotency outcome means re-walking the chain anyway. - **`compareMirrorV2LogID` is a full equality check.** The FSM enforces a contiguous applied prefix (`processMirrorIngest` rejects any `v2LogId` gap with `ErrMirrorV2LogIDGap`), so at rest the stored EN-1550 high-water mark must be exactly `max(audited v2_log_id)`. Any divergence is flagged: `stored > max` claims a source log the audit never recorded; `stored < max` means the projection lost applied ground. A never-mirrored ledger has stored `0` and max `0` → equal → clean. There is no legacy/no-backfill leniency — pre-field clusters are unsupported. The audited max is seeded from a baseline floor (the compact baseline snapshot now includes `Boundary` rows) so archived-only mirror ingests are not undercounted. The comparison is driven from the **union** of stored boundary rows and audited-mirror ledgers, so a mirror ledger whose `Boundary` row is absent while it still has audited ingests (audited max > 0, no row) is treated as stored `0` and flagged — not silently skipped. The absent-row branch is suppressed only for a ledger audited as **deleted** (a `DeleteLedger` log replayed in the verified range, `deletedInReplay`): `WriteSet.Absorb` legitimately removes the boundary row on deletion, so its missing row is expected. Present-row equality still applies to every ledger (including one in the pending-cleanup window whose row is still present). - **Order matters**: `verifyAuditHashChain` runs **first**. A broken chain stops the walk before any downstream pass — running them with a tampered chain would produce noise from already-detected corruption. @@ -78,7 +80,8 @@ flowchart TB B --> J[compareIndexes] B --> L[compareMirrorV2LogID] B --> M[compareReversions] - D & E & F & G & H & I & J & L & M --> K[stream errors as they happen] + B --> N[compareNumscripts] + D & E & F & G & H & I & J & L & M & N --> K[stream errors as they happen] C --> K ``` @@ -110,6 +113,7 @@ enum CheckStoreErrorType { EXCLUSION_RECORD_MISMATCH = 8; IDEMPOTENCY_MISMATCH = 9; INDEX_MISMATCH = 10; + NUMSCRIPT_MISMATCH = 11; } ``` diff --git a/docs/technical/architecture/subsystems/scripting/numscript-library.md b/docs/technical/architecture/subsystems/scripting/numscript-library.md index d5d4ee202a..39232d2d25 100644 --- a/docs/technical/architecture/subsystems/scripting/numscript-library.md +++ b/docs/technical/architecture/subsystems/scripting/numscript-library.md @@ -1,41 +1,38 @@ # Numscript Library -The numscript library is a global repository for storing, retrieving, and managing reusable numscript programs with semantic versioning. Scripts stored in the library can be referenced when creating transactions, avoiding the need to inline the script content in every request. +The numscript library is a per-ledger repository for storing, retrieving, and referencing reusable numscript programs with semantic versioning. Scripts stored in the library can be referenced when creating transactions, avoiding the need to inline the script content in every request. ## Concepts ### Versioning Model -Each numscript is identified by a **name** (e.g. `payment-with-fees`) and can have multiple **versions**: +Each numscript is identified by a **name** (e.g. `payment-with-fees`) scoped to a ledger, and holds one or more **versions**. The library is **immutable and append-only**: -| Version type | Format | Mutability | Example | -|---|---|---|---| -| **Latest** | `"latest"` (or empty) | Overwritable | Always points to the most recently saved "latest" content | -| **Semver** | `major.minor.patch` | Immutable | `1.0.0`, `2.3.1` | +- **Every version is an explicit full semver** (`major.minor.patch`). Saving with an empty, `"latest"`, or partial version is rejected with `NUMSCRIPT_INVALID_VERSION`. +- **Content entries are immutable.** Once `payment-with-fees` `1.0.0` is stored it can never be overwritten or removed. Re-saving the same `(name, version)` returns `NUMSCRIPT_VERSION_ALREADY_EXISTS`. +- **There is no delete and no restore.** Nothing tombstones or clears a version; the only mutation is appending a new one. +- **Each name has a `latest` pointer equal to the greatest stored semver.** Saving advances the pointer to `max(current, saved)`. Versions may be saved out of order — saving `1.0.0` after `2.0.0` leaves the pointer at `2.0.0`. + +Because there is no soft-delete state, a stored version has no derived status: it simply exists, and exactly one of them (the greatest) is what the latest pointer resolves to. -Key rules: -- **"latest" is its own version slot**, independent from semver versions. Saving to "latest" does not overwrite any semver version, and vice versa. -- **Semver versions are immutable.** Once `payment-with-fees` v`1.0.0` is created, it cannot be overwritten. Attempting to do so returns `NUMSCRIPT_VERSION_ALREADY_EXISTS`. -- **Saving with an empty version** defaults to the `"latest"` slot. -- **Deletion is a soft delete.** Deleting a numscript clears its latest-version pointer but preserves all versioned entries in storage. Explicit version lookups (e.g. `?version=1.0.0`) continue to work after deletion. +`ListNumscriptVersions` returns the current latest pointer plus every stored version, ordered highest semver first. `ListNumscripts` returns the greatest version of each named script in the ledger. ### Version Resolution -When reading a numscript (via `GetNumscript` or a `ScriptReference` in a transaction), the `version` field supports several formats. The system resolves them in order: +When reading a numscript (via `GetNumscript` or a `ScriptReference` in a transaction), the `version` selector is resolved as follows: | Input | Strategy | Resolved to | |---|---|---| -| `""` (empty) | Read the latest-version pointer, then recursively resolve that version | Whatever the pointer holds (e.g. `"2.0.0"` or `"latest"`) | -| `"latest"` | Direct lookup on the `latest` slot | The `latest` slot content | +| `""` (empty) or `"latest"` | Read the latest pointer (greatest stored semver), then fetch that exact version | Greatest stored semver, or `NOT_FOUND` if the name has no versions | | `"1.0.0"` (full semver) | Direct lookup on the exact semver key | Exact match or `NOT_FOUND` | | `"1.0"` (major.minor) | Range scan `[1.0.0, 1.1.0)`, take the **highest** | Highest `1.0.x` patch | | `"1"` (major only) | Range scan `[1.0.0, 2.0.0)`, take the **highest** | Highest `1.x.y` minor+patch | -Partial versions are parsed by `semver.ParsePartial()` (`internal/semver/`). Range scans exploit the big-endian uint32 encoding of semver components in Pebble keys, which ensures lexicographic order matches semantic order. +Partial selectors (`"1"`, `"1.0"`) are a **read-only** convenience parsed by `semver.ParsePartial()` (`internal/pkg/semver/`). They are valid for `GetNumscript` and transaction references but rejected on save (only full semver is storable). ### Syntax Validation -Scripts are parsed and validated **at save time**, not at transaction creation time. This catches syntax errors early. The parser uses the same Numscript interpreter as transaction execution, with all experimental features enabled. +Scripts are parsed and validated **at save time**, not at transaction-creation time. This catches syntax errors early. The parser uses the same Numscript interpreter as transaction execution, with all experimental features enabled. ## API @@ -43,10 +40,10 @@ Scripts are parsed and validated **at save time**, not at transaction creation t | Method | Path | Description | |---|---|---| -| `PUT` | `/numscripts/{name}` | Save a numscript (create or update latest) | -| `GET` | `/numscripts/{name}?version=` | Get a numscript (empty version = latest) | -| `GET` | `/numscripts` | List all numscripts (latest version of each) | -| `DELETE` | `/numscripts/{name}` | Soft-delete a numscript | +| `PUT` | `/numscripts/{name}` | Save a new immutable version (explicit full semver) | +| `GET` | `/numscripts/{name}?version=` | Get a numscript (empty/`latest` = greatest semver) | +| `GET` | `/numscripts/{name}/versions` | List the latest pointer and every stored version | +| `GET` | `/numscripts` | List the greatest version of each named script | #### Save Numscript @@ -60,7 +57,7 @@ Content-Type: application/json } ``` -Response: `201 Created` with a log entry containing the `NumscriptInfo`. +Response: `201 Created` with a log entry containing the `NumscriptInfo`. Returns `409` if the version already exists, `400` if the version is not a full semver or the content fails to parse. #### Get Numscript @@ -68,52 +65,52 @@ Response: `201 Created` with a log entry containing the `NumscriptInfo`. GET /numscripts/payment-with-fees?version=1.0.0 ``` -Response: `200 OK` with `NumscriptInfo` (name, content, version, createdAt). -Returns `404` if the numscript or version does not exist. +Response: `200 OK` with `NumscriptInfo` (name, content, version, createdAt). Returns `404` if the numscript or version does not exist. -#### List Numscripts +#### List Numscript Versions ``` -GET /numscripts +GET /numscripts/payment-with-fees/versions ``` -Response: `200 OK` with an array of `NumscriptInfo` (latest version of each script). +Response: `200 OK` with the current latest version and every stored version (highest semver first). -#### Delete Numscript +#### List Numscripts ``` -DELETE /numscripts/payment-with-fees +GET /numscripts ``` -Response: `204 No Content`. Returns `404` if the numscript does not exist. +Response: `200 OK` with an array of `NumscriptInfo` (greatest version of each named script). ### gRPC The `BucketService` exposes: -- `SaveNumscript` / `DeleteNumscript` via the `Apply` RPC (write operations go through Raft) +- `SaveNumscript` via the `Apply` RPC (the only write; goes through Raft) - `GetNumscript(GetNumscriptRequest) returns (NumscriptInfo)` (read) - `ListNumscripts(ListNumscriptsRequest) returns (stream NumscriptInfo)` (read, streaming) +- `ListNumscriptVersions(ListNumscriptVersionsRequest) returns (ListNumscriptVersionsResponse)` (read; response carries `latest_version` + `versions`) ### CLI ```bash -# Save from a file +# Save a version (explicit full semver, required) ledgerctl numscripts save payment-with-fees --file script.num --version 1.0.0 # Save from stdin -cat script.num | ledgerctl numscripts save payment-with-fees +cat script.num | ledgerctl numscripts save payment-with-fees --version 1.0.0 -# Get latest version +# Get latest version (greatest stored semver) ledgerctl numscripts get payment-with-fees # Get specific version ledgerctl numscripts get payment-with-fees --version 1.0.0 -# List all +# List the greatest version of each script ledgerctl numscripts list -# Delete -ledgerctl numscripts delete payment-with-fees +# List the latest pointer and every stored version +ledgerctl numscripts versions payment-with-fees ``` ## Error Handling @@ -123,20 +120,20 @@ ledgerctl numscripts delete payment-with-fees | Name required | — | 400 | INVALID_ARGUMENT | Empty name | | Content required | — | 400 | INVALID_ARGUMENT | Empty content | | Parse error | `NUMSCRIPT_PARSE_ERROR` | 400 | INVALID_ARGUMENT | Invalid Numscript syntax | -| Invalid version | `NUMSCRIPT_INVALID_VERSION` | 400 | INVALID_ARGUMENT | Version is not "latest", empty, or valid semver | -| Version exists | `NUMSCRIPT_VERSION_ALREADY_EXISTS` | 409 | ALREADY_EXISTS | Immutable semver already saved | -| Not found | `NUMSCRIPT_NOT_FOUND` | 404 | NOT_FOUND | Get/delete non-existent numscript | +| Invalid version | `NUMSCRIPT_INVALID_VERSION` | 400 | INVALID_ARGUMENT | Save version is not a full semver | +| Version exists | `NUMSCRIPT_VERSION_ALREADY_EXISTS` | 409 | ALREADY_EXISTS | The `(name, version)` is already stored (immutable) | +| Not found | `NUMSCRIPT_NOT_FOUND` | 404 | NOT_FOUND | Get a non-existent numscript or version | ## Script References in Transactions -Instead of inlining a numscript in every `CreateTransaction` request, clients can pass a `ScriptReference` that points to a script stored in the library. The version resolution described in [Version Resolution](#version-resolution) applies here. +Instead of inlining a numscript in every `CreateTransaction` request, clients can pass a `ScriptReference` that points to a script stored in the library. The [version resolution](#version-resolution) rules apply to the reference's `version` selector. ### Protobuf ```protobuf message ScriptReference { string name = 1; - string version = 2; // "" = latest pointer + string version = 2; // "" / "latest" = greatest stored semver map vars = 3; } @@ -146,36 +143,46 @@ message CreateTransactionPayload { } ``` -### Resolution Flow +### Resolution Flow — admission plans, the FSM resolves + +Numscript content is a Pebble-backed projection, and the FSM apply path must never read Pebble (invariant #3) — so a transaction that references `"latest"` cannot resolve the pointer at apply time by itself. Resolution is split between admission (which reads Pebble but must not mutate the audited order) and the FSM (which is deterministic but reads only the cache through the coverage gate): + +1. **Admission does not rewrite the reference.** The `"latest"` (or exact) selector is carried into the `raftcmdpb.Order` verbatim so the audited command matches what the client sent. Admission's only job is to *plan* the reads the FSM will make. +2. **Admission declares the coverage the FSM needs.** For a `"latest"` reference it declares the per-name latest-pointer key (`SubAttrNumscriptVersion`) and, having discovered the current greatest semver, the corresponding content key (`SubAttrNumscriptContent`). The greatest is computed as `max(intra-bulk overlay, persisted)` so a save earlier in the same bulk is visible. +3. **The FSM resolves at apply time.** `processCreateTransaction` reads the latest pointer through the gated `Scope`, then checks that the greatest version's content was actually preloaded: -Version resolution happens in the **admission layer** (`admission.go`), before the Raft proposal is built. This means the script content is resolved at request time from Pebble, not from the FSM caches. + ```go + greatest, _ := s.GetNumscriptLatestVersion(ledger, name) + if s.CheckCoverage(dal.SubAttrNumscriptContent, + domain.NumscriptEntryKey{LedgerName: ledger, Name: name, Version: greatest}) != nil { + return domain.ErrStaleProposal // retryable + } + info, _ := s.ResolveNumscriptContent(ledger, name, greatest) + ``` + +4. **Skew is handled by stale-retry.** If another proposal advanced the latest pointer between admission's read and this apply, the content the FSM now needs was never preloaded, the coverage check misses, and the order is rejected with `ErrStaleProposal` (`KindUnavailable`, retryable). Re-admission observes the new greatest and declares the right content key. This is the same class of backstop as `PredictedIndex`: a no-op on the happy path, a bounded retry on genuine cross-proposal races. ``` -POST /{ledger}/transactions { scriptReference: { name: "payment", version: "1" } } +POST /{ledger}/transactions { scriptReference: { name: "payment", version: "latest" } } │ ▼ -Admission: resolveScriptReference() - │ - ├── Validate: script and scriptReference are mutually exclusive - │ (both set → INVALID_ARGUMENT) +Admission + ├── keep the "latest" selector in the Order (no mutation) + ├── discover greatest = max(overlay, Pebble) + └── declare needs: SubAttrNumscriptVersion{name} + SubAttrNumscriptContent{name, greatest} │ - ├── ReadNumscript(store, name="payment", version="1") - │ │ - │ ▼ - │ semver.ParsePartial("1") → major=1, depth=1 - │ │ - │ ▼ - │ resolvePartialVersion(): range scan [1.0.0, 2.0.0) - │ │ - │ ▼ - │ iter.Last() → NumscriptInfo { version: "1.3.0", content: "..." } + ▼ +Raft replication (all nodes) │ - ├── If nil → NUMSCRIPT_NOT_FOUND + ▼ +FSM Apply: processCreateTransaction + ├── GetNumscriptLatestVersion → greatest + ├── CheckCoverage(SubAttrNumscriptContent, {name, greatest}) + │ └── miss → ErrStaleProposal (retry) + └── ResolveNumscriptContent(name, greatest) → content │ - └── Build Script { plain: info.Content, vars: scriptReference.Vars } - │ - ▼ - Normal transaction processing (parse, execute, postings...) + ▼ +Normal transaction processing (parse, execute, postings...) ``` ### Version Pinning Examples @@ -184,10 +191,10 @@ Given a library with versions `1.0.0`, `1.0.5`, `1.2.0`, `2.0.0`: | `scriptReference.version` | Resolved version | Behavior | |---|---|---| -| `""` | Latest pointer (e.g. `"2.0.0"`) | Follows whatever version was last saved | +| `""` / `"latest"` | `2.0.0` (greatest) | Follows the greatest stored semver | | `"1.0.0"` | `1.0.0` | Exact pin, never changes | -| `"1.0"` | `1.0.5` | Picks highest patch in `1.0.x` — auto-updates when `1.0.6` is saved | -| `"1"` | `1.2.0` | Picks highest minor+patch in `1.x.y` — auto-updates within major | +| `"1.0"` | `1.0.5` | Highest patch in `1.0.x` — auto-updates when `1.0.6` is saved | +| `"1"` | `1.2.0` | Highest minor+patch in `1.x.y` — auto-updates within major | | `"2.0.0"` | `2.0.0` | Exact pin | | `"3"` | `NOT_FOUND` | No version in the `3.x.y` range | @@ -197,22 +204,20 @@ Given a library with versions `1.0.0`, `1.0.5`, `1.2.0`, `2.0.0`: |---|---|---| | Both `script` and `scriptReference` set | `INVALID_ARGUMENT` | `SCRIPT_AND_REFERENCE_CONFLICT` | | Script name not found / version not found | `NOT_FOUND` | `NUMSCRIPT_NOT_FOUND` | +| Latest advanced between admission and apply | `UNAVAILABLE` | `ErrStaleProposal` (client retries) | ## Storage -### Pebble Keys - -Three key formats store numscript data: +Numscript data lives in the attributes zone as two projections, both keyed by ledger-scoped keys (`internal/domain/keys.go`) and codified by sub-attribute codes (`internal/storage/dal/store.go`): -| Prefix | Key format | Value | -|---|---|---| -| `KeyPrefixNumscript` (semver) | `[prefix][name]\x00\x00[major_u32BE][minor_u32BE][patch_u32BE]` | Protobuf `NumscriptInfo` | -| `KeyPrefixNumscript` (latest) | `[prefix][name]\x00\x01` | Protobuf `NumscriptInfo` | -| `KeyPrefixNumscriptLatest` | `[prefix][name]` | Version string (UTF-8 bytes) | +| Sub-attribute | Key | Value | Purpose | +|---|---|---|---| +| `SubAttrNumscriptContent` (`0x0A`) | `NumscriptEntryKey{LedgerName, Name, Version}` | `NumscriptInfo` | Immutable per-version content entry | +| `SubAttrNumscriptVersion` (`0x09`) | `NumscriptVersionKey{LedgerName, Name}` | `NumscriptVersionValue` | Per-name latest pointer (greatest stored semver) | -The `\x00` byte after the name is a separator. The next byte is a **tag**: `0x00` = semver entry, `0x01` = latest slot (constants `NumscriptVersionTagSemver` / `NumscriptVersionTagLatest` in `dal/types.go`). Semver components are encoded as big-endian `uint32`, which guarantees lexicographic key order matches semantic version order — enabling efficient range scans for partial version resolution. +`NumscriptEntryKey` encodes `[ledger padded 64B][name]\x00[version]`; the version is stored as a plain semver string. `NumscriptVersionKey` encodes `[ledger padded 64B][name]`. Partial-version range scans on the read path exploit the ordering of the semver-string component within the content key range. -The latest-version pointer is a simple string that tells the system which version to resolve when no explicit version is requested. On soft delete, this key is written with an empty value (not deleted from Pebble), preserving the key's existence for the storage layer. +Both projections are audit-log derivable and are re-verified by the checker — see [Checker: `compareNumscripts`](../checker/checker.md). ### Attribute Caches @@ -220,38 +225,23 @@ Numscript data uses the same preloading pattern as other system attributes (see | Cache | Key type | Value type | Purpose | |---|---|---|---| -| `NumscriptVersions` | `NumscriptVersionKey{Name}` | `string` | Latest version pointer per name | -| `NumscriptEntries` | `NumscriptEntryKey{Name, Version}` | `bool` | Per-version existence (for semver immutability checks) | +| `NumscriptVersions` | `NumscriptVersionKey{LedgerName, Name}` | `NumscriptVersionValue` | Latest pointer per name | +| `NumscriptContents` | `NumscriptEntryKey{LedgerName, Name, Version}` | `NumscriptInfo` | Per-version content | -Both use `KeyStore` (Machine) + `DerivedKeyStore` (WriteSet) + `AttributeCache` (Cache) + `AttributeLoader` (Admission). +The FSM reads both only through the gated `Scope` (`GetNumscriptLatestVersion`, `ResolveNumscriptContent`, `CheckCoverage`), so every read is admitted by the per-order coverage bits (invariant #9). ### Admission Preloading -Before a `SaveNumscript` or `DeleteNumscript` order enters Raft, the admission layer preloads: - -1. **NumscriptVersions** — the current latest-version pointer for the script name. Always preloaded (both existing and empty values). -2. **NumscriptEntries** — for semver saves only, whether the specific `(name, version)` entry already exists. This is skipped for `"latest"` saves since they are always overwritable. - -Preload messages sent in the Raft proposal: - -```protobuf -message PreloadNumscriptVersion { - AttributeID id = 1; - string version = 2; // "" means not found -} - -message PreloadNumscriptEntry { - AttributeID id = 1; - bool exists = 2; // true if version already stored -} -``` +- **Save.** Admission declares both the latest pointer (`SubAttrNumscriptVersion`) and the target content key (`SubAttrNumscriptContent`) for the `(name, version)` being written, so the FSM can enforce immutability (duplicate → `NUMSCRIPT_VERSION_ALREADY_EXISTS`) and advance the pointer to the greatest semver. +- **Reference.** For a `"latest"`/empty reference, admission declares the latest pointer plus the content key for the discovered greatest semver (see [Resolution Flow](#resolution-flow--admission-plans-the-fsm-resolves)). For an exact reference, it declares just that content key. Absent keys are declared with a `Declare` plan so a never-recorded script surfaces as `ErrNotFound` (→ `NUMSCRIPT_NOT_FOUND`) rather than a coverage fault. ### Intra-Batch Propagation -Multiple orders in a single Raft proposal share the same `WriteSet` state. The `DerivedKeyStore` overlay ensures later orders see writes from earlier orders in the same batch. For example: +Multiple orders in a single Raft proposal share the same `WriteSet` state; the `Derived` overlay ensures later orders see earlier writes. Admission plans a bulk sequentially with a greatest-wins overlay so, e.g.: -1. Order 1: `SaveNumscript("transfer", "1.0.0")` — succeeds, entry cached -2. Order 2: `SaveNumscript("transfer", "1.0.0")` — fails with `NUMSCRIPT_VERSION_ALREADY_EXISTS` (sees Order 1's write) +1. Order 1: `SaveNumscript("transfer", "1.0.0")` — succeeds, pointer → `1.0.0` +2. Order 2: `SaveNumscript("transfer", "2.0.0")` — succeeds, pointer → `2.0.0` +3. Order 3: transaction referencing `"latest"` — resolves to `2.0.0` (sees Orders 1–2) ## Architecture @@ -267,23 +257,25 @@ HTTP Handler → backend.Apply(SaveNumscriptRequest) Controller → Raft Propose(SaveNumscriptOrder) │ ▼ -Admission: extractPreloadNeeds() - ├── NumscriptVersions: preload latest pointer from Pebble - └── NumscriptEntries: preload version existence from Pebble (semver only) +Admission: extractLedgerScopedNeeds() + ├── SubAttrNumscriptVersion: latest pointer from Pebble + └── SubAttrNumscriptContent: target (name, version) entry from Pebble │ ▼ Raft replication (all nodes) │ ▼ FSM Apply: processSaveNumscript() - ├── Validate name, content, syntax - ├── Resolve version ("latest" or semver immutability check) - └── PutNumscript(info) → WriteSet state + ├── semver.Parse(version) — reject non-full-semver + ├── duplicate content → NUMSCRIPT_VERSION_ALREADY_EXISTS + ├── read current greatest (before write) + ├── PutNumscript(info) + └── if greatest > saved: keep pointer; else advance to saved │ ▼ WriteSet.Merge() - ├── SaveNumscript → Pebble (versioned entry + latest pointer) - └── DerivedKeyStore.Merge() → update Machine KeyStore + ├── content entry → Pebble (SubAttrNumscriptContent) + └── latest pointer → Pebble (SubAttrNumscriptVersion) ``` ### Read Path @@ -295,38 +287,17 @@ HTTP GET /numscripts/{name}?version= HTTP Handler → backend.GetNumscript(name, version) │ ▼ -Controller → ReadNumscript(store, name, version) - │ - ├── version == "" - │ → ReadNumscriptLatestVersion(name) → pointer (e.g. "2.0.0") - │ → ReadNumscript(name, "2.0.0") (recursive) +Controller → query.ReadNumscript(versionAttr, contentAttr, reader, ledger, name, version) │ - ├── version == "latest" - │ → readNumscriptLatestSlot(): direct Get on [prefix][name]\x00\x01 + ├── version == "" / "latest" + │ → ReadNumscriptLatestVersion(name) → greatest (e.g. "2.0.0") + │ → readNumscriptExact(name, "2.0.0") │ ├── depth == 3 (e.g. "1.0.0") - │ → readNumscriptExactSemver(): direct Get on [prefix][name]\x00\x00[1][0][0] + │ → readNumscriptExact(name, "1.0.0") │ └── depth < 3 (e.g. "1" or "1.0") - → resolvePartialVersion(): range scan, iter.Last() -``` - -### Delete Path - -``` -HTTP DELETE /numscripts/{name} - │ - ▼ -Admission → preload NumscriptVersions - │ - ▼ -FSM Apply: processDeleteNumscript() - ├── Check latest version exists (from cache, not Pebble) - └── DeleteNumscriptLatest(name) → clear latest pointer (soft delete) - │ - ▼ -WriteSet.Merge() - └── ClearNumscriptLatestVersion → write empty value to Pebble + → resolvePartialVersion(): range scan, highest match ``` ## File Map @@ -336,30 +307,32 @@ WriteSet.Merge() | HTTP | `internal/adapter/http/handlers_save_numscript.go` | PUT handler | | HTTP | `internal/adapter/http/handlers_get_numscript.go` | GET handler | | HTTP | `internal/adapter/http/handlers_list_numscripts.go` | List handler | -| HTTP | `internal/adapter/http/handlers_delete_numscript.go` | DELETE handler | -| CLI | `cmd/ledgerctl/numscripts/` | One file per subcommand | -| Business logic | `internal/domain/processing/processor_numscript_library.go` | Save/delete processors | -| Errors | `internal/domain/errors.go` | Error types and reason codes | -| Store interface | `internal/domain/processing/store.go` | `InMemoryStore` numscript methods | -| State buffer | `internal/infra/state/buffer.go` | `WriteSet` numscript operations | -| State registry | `internal/infra/state/registry.go` | `NumscriptVersions`, `NumscriptEntries` KeyStores | -| Pebble batch | `internal/infra/state/batch.go` | `SaveNumscript`, `ClearNumscriptLatestVersion` | -| Query | `internal/query/store.go` | `ReadNumscript`, `ReadNumscriptLatestVersion` | -| Cache | `internal/infra/cache/cache.go` | `NumscriptVersions`, `NumscriptEntries` caches | -| Admission | `internal/application/admission/admission.go` | Preload and script reference resolution | -| Loaders | `internal/application/admission/loader.go` | `NumscriptVersions`, `NumscriptEntries` loaders | -| Semver | `internal/semver/semver.go` | `Version`, `Parse`, `ParsePartial` | -| DAL keys | `internal/domain/keys.go` | `NumscriptVersionKey`, `NumscriptEntryKey`, version tag constants | -| DAL key builder | `internal/storage/dal/key_builder.go` | Pebble key encoding | -| Proto | `misc/proto/common.proto` | `NumscriptInfo`, log payload messages | -| Proto | `misc/proto/raft_cmd.proto` | `SaveNumscriptOrder`, `DeleteNumscriptOrder`, preload messages | +| HTTP | `internal/adapter/http/handlers_list_numscript_versions.go` | List-versions handler | +| CLI | `cmd/ledgerctl/numscripts/` | One file per subcommand (`save`, `get`, `list`, `versions`) | +| Business logic | `internal/domain/processing/processor_numscript_library.go` | `processSaveNumscript` | +| FSM reference resolution | `internal/domain/processing/processor_transaction.go` | Latest-pointer resolution + coverage check | +| Errors | `internal/domain/errors.go`, `reason.go` | Error types and reason codes | +| Scope interface | `internal/domain/processing/store.go` | `Scope` numscript methods | +| State buffer | `internal/infra/state/write_set.go` | `PutNumscript`, `SetNumscriptLatestVersion`, `GetNumscriptLatestVersion`, `ResolveNumscriptContent` | +| Gated scope | `internal/infra/state/scope.go` | Coverage-gated numscript reads | +| Query | `internal/query/numscript.go` | `ReadNumscript`, `ReadNumscriptLatestVersion`, `ReadAllNumscripts`, `ReadAllNumscriptVersions` | +| Admission | `internal/application/admission/admission.go` | Needs declaration + script reference planning | +| Admission overlay | `internal/application/admission/overlay.go` | Intra-bulk greatest-wins overlay | +| Checker | `internal/application/check/checker.go` | `compareNumscripts` projection verification | +| Rebuild | `internal/infra/backup/rebuild.go` | Projection rebuild from the audit chain | +| Semver | `internal/pkg/semver/semver.go` | `Version`, `Parse`, `ParsePartial`, `Compare` | +| DAL keys | `internal/domain/keys.go` | `NumscriptVersionKey`, `NumscriptEntryKey` | +| DAL codes | `internal/storage/dal/store.go` | `SubAttrNumscriptVersion`, `SubAttrNumscriptContent` | +| Proto | `misc/proto/common.proto` | `NumscriptInfo`, `NumscriptVersionValue`, `NumscriptVersionEntry` | +| Proto | `misc/proto/raft_cmd.proto` | `SaveNumscriptOrder` | | Proto | `misc/proto/bucket.proto` | gRPC service methods, `ScriptReference` | | gRPC errors | `internal/adapter/grpc/errors.go` | Error-to-gRPC-status mapping | -| E2E tests | `tests/e2e/numscript_library_test.go` | Library CRUD and versioning tests | +| E2E tests | `tests/e2e/business/numscript_library_test.go` | Library and versioning tests | ## Related Documentation - [Numscript Language](../../../contributing/numscript.md) — DSL syntax, features, and usage in transactions - [Deterministic FSM](../fsm/deterministic-fsm.md) — Cache, preloading, and generation-based architecture +- [Checker](../checker/checker.md) — `compareNumscripts` projection verification - [System Attributes](../attributes/attributes.md) — Attribute types, caching, and compaction - [API Comparison](../../../contributing/api-comparison.md) — Feature parity tracking diff --git a/docs/technical/contributing/api-comparison.md b/docs/technical/contributing/api-comparison.md index 777ff923bf..583a525145 100644 --- a/docs/technical/contributing/api-comparison.md +++ b/docs/technical/contributing/api-comparison.md @@ -68,10 +68,10 @@ This document compares the POC's API with the original Formance ledger API and d | Unique reference validation | ✅ | ✅ | Per-ledger uniqueness, HTTP 409 on conflict | | Skip-on-conflict opt-in | ✅ | ❌ | Per-entry `skippableReasons: ["TRANSACTION_REFERENCE_CONFLICT"]` on the bulk endpoint → the entry's `BulkResult.data` carries an `OrderSkippedResponse` shape instead of the normal Transaction. The unitary POST endpoint intentionally does NOT expose the opt-in (a single-tx caller can catch the 4xx directly); gRPC clients can set `LedgerApplyRequest.skippable_reasons` on any Apply. | | **Numscript Library** | -| Save numscript (versioned) | ✅ | ❌ | Per-ledger, semver versioning (e.g. "1.0.0") | -| Get numscript (by version) | ✅ | ❌ | Per-ledger, query param `?version=1.0.0`, empty = latest | -| List numscripts | ✅ | ❌ | Per-ledger, lists all saved numscripts | -| Delete numscript | ✅ | ❌ | Per-ledger, deletes latest version entry | +| Save numscript (versioned) | ✅ | ❌ | Per-ledger, immutable append-only, explicit full semver (e.g. "1.0.0"). Re-saving a version returns `NUMSCRIPT_VERSION_ALREADY_EXISTS` | +| Get numscript (by version) | ✅ | ❌ | Per-ledger, `?version=1.0.0`; empty/`latest` = greatest stored semver; partial selectors (`1`, `1.2`) allowed | +| List numscripts | ✅ | ❌ | Per-ledger, greatest version of each | +| List numscript versions | ✅ | ❌ | Per-ledger, `GET .../numscripts/{name}/versions`, current latest + every stored version | | **Audit Log** | | Audit log (success + failure) | ✅ | ❌ | Replicated via Raft, stored in Pebble | | List audit entries | ✅ | ❌ | `GET /v3/_/audit-entries` (HTTP) + gRPC stream. Bucket-wide; `pageSize`/`after`/`reverse` + a bare-audit-field filter expression (`outcome`, `ledger`, `seq`, `proposal_id`, `timestamp`, `log_seq`, `caller_subject`, `order_type`, resolved against the audit query target — EN-1549 replaced the old `audit[...]` namespaced syntax; textual form only, audit has no structured JSON form — see [Filter input formats](#filter-input-formats-dual-format-contract-en-1511)) | @@ -371,11 +371,11 @@ Promoting a non-mirror ledger returns HTTP 400 (`LEDGER_NOT_IN_MIRROR_MODE`) or The numscript library allows saving, retrieving, and managing reusable numscript programs with semver versioning. **Endpoints:** -- `GET /v3/{ledgerName}/numscripts` - List all saved numscripts for a ledger -- `GET /v3/{ledgerName}/numscripts/{name}?version=` - Get a numscript by name (optional version query param) +- `GET /v3/{ledgerName}/numscripts` - List all numscripts (greatest version of each) +- `GET /v3/{ledgerName}/numscripts/{name}?version=` - Get a numscript by name (optional version selector) - `GET /v3/{ledgerName}/numscripts/{name}/usage` - Get invocation count and last-used timestamp for a template -- `PUT /v3/{ledgerName}/numscripts/{name}` - Save a numscript (create new version or overwrite latest) -- `DELETE /v3/{ledgerName}/numscripts/{name}` - Delete a numscript +- `GET /v3/{ledgerName}/numscripts/{name}/versions` - List version history (current latest + every stored version) +- `PUT /v3/{ledgerName}/numscripts/{name}` - Save an immutable version (explicit full semver) **Versioning:** @@ -776,11 +776,11 @@ Read endpoints comparison with the original ledger: | `DELETE /v3/{ledgerName}/prepared-queries/{queryName}` | ✅ | ❌ | Delete a prepared query | | `GET /v3/{ledgerName}/prepared-queries` | ✅ | ❌ | List prepared queries | | `POST /v3/{ledgerName}/prepared-queries/{queryName}/execute` | ✅ | ❌ | Execute a prepared query | -| `GET /v3/{ledgerName}/numscripts` | ✅ | ❌ | List all numscripts for a ledger | -| `GET /v3/{ledgerName}/numscripts/{name}?version=` | ✅ | ❌ | Get numscript (semver version, empty = latest) | +| `GET /v3/{ledgerName}/numscripts` | ✅ | ❌ | List all numscripts (greatest version of each) | +| `GET /v3/{ledgerName}/numscripts/{name}?version=` | ✅ | ❌ | Get numscript (version selector, empty/latest = greatest semver) | | `GET /v3/{ledgerName}/numscripts/{name}/usage` | ✅ | ❌ | Get invocation count + last-used timestamp | -| `PUT /v3/{ledgerName}/numscripts/{name}` | ✅ | ❌ | Save numscript (semver versioned) | -| `DELETE /v3/{ledgerName}/numscripts/{name}` | ✅ | ❌ | Delete numscript | +| `GET /v3/{ledgerName}/numscripts/{name}/versions` | ✅ | ❌ | List version history | +| `PUT /v3/{ledgerName}/numscripts/{name}` | ✅ | ❌ | Save an immutable version (explicit full semver) | | `GET /v3/{ledgerName}/account-types` | ✅ | ❌ | List account types | | `GET /v3/{ledgerName}/account-types/{typeName}` | ✅ | ❌ | Get account type | | `POST /v3/{ledgerName}/account-types` | ✅ | ❌ | Add account type | @@ -866,10 +866,10 @@ The POC provides a gRPC API for internal service communication (Raft node forwar | `Apply` | Apply a ledger action (write operations) | ✅ | | `Apply(CreateLedger)` with mirror mode | Create a mirror ledger | ✅ | | `Apply(PromoteLedger)` | Promote mirror ledger to normal mode | ✅ | -| `Apply(SaveNumscript)` | Save a numscript (semver versioned) | ✅ | -| `Apply(DeleteNumscript)` | Delete a numscript | ✅ | -| `GetNumscript` | Get a numscript by name and optional version | ✅ | -| `ListNumscripts` | List all saved numscripts | ✅ | +| `Apply(SaveNumscript)` | Save an immutable numscript version (explicit full semver) | ✅ | +| `GetNumscript` | Get a numscript by name and version selector | ✅ | +| `ListNumscripts` | List the greatest version of each saved numscript | ✅ | +| `ListNumscriptVersions` | List the latest pointer and every stored version | ✅ | | `Apply(CloseChapter)` | Close the current open chapter | ✅ | | `ListChapters` | Stream all chapters | ✅ | | `ListAuditEntries` | Stream audit log entries (success + failure). Request is `{ options }` only — no dedicated filter fields. Follows the shared `ListOptions` contract: cursor/page_size/reverse/checkpoint_id plus a bare-audit-field `QueryFilter` (outcome, ledger, caller_subject, order_type, seq, proposal_id, timestamp, log_seq — bare fields resolved against the audit query target, EN-1549 replacing the old `audit[...]` syntax) resolved through the audit secondary index. Ledger scope and outcome selection are expressed as filter conditions | ✅ | @@ -904,8 +904,7 @@ The `Apply` method is the **single entry point for all ledger write operations** - `add_metadata`: Add metadata to an account or transaction - `revert_transaction`: Revert a transaction - `delete_metadata`: Delete metadata from an account or transaction - - `save_numscript`: Save a numscript (with semver version) - - `delete_numscript`: Delete a numscript + - `save_numscript`: Save an immutable numscript version (explicit full semver) **Response:** `common.Log` - The log entry created by the action (stripped to `sequence` only when `skip_response` is set) diff --git a/internal/adapter/grpc/bucket_service_client_generated_test.go b/internal/adapter/grpc/bucket_service_client_generated_test.go index 3ec3224ae5..fa0e2efa74 100644 --- a/internal/adapter/grpc/bucket_service_client_generated_test.go +++ b/internal/adapter/grpc/bucket_service_client_generated_test.go @@ -1494,6 +1494,50 @@ func (c *MockBucketServiceClientListLogsCall) DoAndReturn(f func(context.Context return c } +// ListNumscriptVersions mocks base method. +func (m *MockBucketServiceClient) ListNumscriptVersions(ctx context.Context, in *servicepb.ListNumscriptVersionsRequest, opts ...grpc.CallOption) (*servicepb.ListNumscriptVersionsResponse, error) { + m.ctrl.T.Helper() + varargs := []any{ctx, in} + for _, a := range opts { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "ListNumscriptVersions", varargs...) + ret0, _ := ret[0].(*servicepb.ListNumscriptVersionsResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ListNumscriptVersions indicates an expected call of ListNumscriptVersions. +func (mr *MockBucketServiceClientMockRecorder) ListNumscriptVersions(ctx, in any, opts ...any) *MockBucketServiceClientListNumscriptVersionsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{ctx, in}, opts...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNumscriptVersions", reflect.TypeOf((*MockBucketServiceClient)(nil).ListNumscriptVersions), varargs...) + return &MockBucketServiceClientListNumscriptVersionsCall{Call: call} +} + +// MockBucketServiceClientListNumscriptVersionsCall wrap *gomock.Call +type MockBucketServiceClientListNumscriptVersionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBucketServiceClientListNumscriptVersionsCall) Return(arg0 *servicepb.ListNumscriptVersionsResponse, arg1 error) *MockBucketServiceClientListNumscriptVersionsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBucketServiceClientListNumscriptVersionsCall) Do(f func(context.Context, *servicepb.ListNumscriptVersionsRequest, ...grpc.CallOption) (*servicepb.ListNumscriptVersionsResponse, error)) *MockBucketServiceClientListNumscriptVersionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBucketServiceClientListNumscriptVersionsCall) DoAndReturn(f func(context.Context, *servicepb.ListNumscriptVersionsRequest, ...grpc.CallOption) (*servicepb.ListNumscriptVersionsResponse, error)) *MockBucketServiceClientListNumscriptVersionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // ListNumscripts mocks base method. func (m *MockBucketServiceClient) ListNumscripts(ctx context.Context, in *servicepb.ListNumscriptsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[commonpb.NumscriptInfo], error) { m.ctrl.T.Helper() diff --git a/internal/adapter/grpc/client_bucket.go b/internal/adapter/grpc/client_bucket.go index ab0463ac44..da55466cfc 100644 --- a/internal/adapter/grpc/client_bucket.go +++ b/internal/adapter/grpc/client_bucket.go @@ -466,6 +466,18 @@ func (g *BucketGrpcClient) ListNumscripts(ctx context.Context, ledger string) ([ } } +func (g *BucketGrpcClient) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + resp, err := g.client.ListNumscriptVersions(ctx, &servicepb.ListNumscriptVersionsRequest{ + Ledger: ledger, + Name: name, + }) + if err != nil { + return "", nil, fmt.Errorf("gRPC ListNumscriptVersions call failed: %w", err) + } + + return resp.GetLatestVersion(), resp.GetVersions(), nil +} + func (g *BucketGrpcClient) GetChapterSchedule(ctx context.Context) (string, error) { resp, err := g.client.GetChapterSchedule(ctx, &servicepb.GetChapterScheduleRequest{}) if err != nil { diff --git a/internal/adapter/grpc/controller_generated_test.go b/internal/adapter/grpc/controller_generated_test.go index b72b69315c..5bc24c0bf5 100644 --- a/internal/adapter/grpc/controller_generated_test.go +++ b/internal/adapter/grpc/controller_generated_test.go @@ -1099,6 +1099,46 @@ func (c *MockControllerListLogsCall) DoAndReturn(f func(context.Context, string, return c } +// ListNumscriptVersions mocks base method. +func (m *MockController) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNumscriptVersions", ctx, ledger, name) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].([]*commonpb.NumscriptVersionEntry) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ListNumscriptVersions indicates an expected call of ListNumscriptVersions. +func (mr *MockControllerMockRecorder) ListNumscriptVersions(ctx, ledger, name any) *MockControllerListNumscriptVersionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNumscriptVersions", reflect.TypeOf((*MockController)(nil).ListNumscriptVersions), ctx, ledger, name) + return &MockControllerListNumscriptVersionsCall{Call: call} +} + +// MockControllerListNumscriptVersionsCall wrap *gomock.Call +type MockControllerListNumscriptVersionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockControllerListNumscriptVersionsCall) Return(arg0 string, arg1 []*commonpb.NumscriptVersionEntry, arg2 error) *MockControllerListNumscriptVersionsCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockControllerListNumscriptVersionsCall) Do(f func(context.Context, string, string) (string, []*commonpb.NumscriptVersionEntry, error)) *MockControllerListNumscriptVersionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockControllerListNumscriptVersionsCall) DoAndReturn(f func(context.Context, string, string) (string, []*commonpb.NumscriptVersionEntry, error)) *MockControllerListNumscriptVersionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // ListNumscripts mocks base method. func (m *MockController) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) { m.ctrl.T.Helper() diff --git a/internal/adapter/grpc/server_bucket.go b/internal/adapter/grpc/server_bucket.go index d3ecb8bbc6..be7d98f6b2 100644 --- a/internal/adapter/grpc/server_bucket.go +++ b/internal/adapter/grpc/server_bucket.go @@ -1502,6 +1502,33 @@ func (impl *BucketServiceServerImpl) ListNumscripts(req *servicepb.ListNumscript }) } +func (impl *BucketServiceServerImpl) ListNumscriptVersions(ctx context.Context, req *servicepb.ListNumscriptVersionsRequest) (*servicepb.ListNumscriptVersionsResponse, error) { + if _, err := internalauth.Authenticate(ctx, impl.authCfg, internalauth.ScopeQueriesRead); err != nil { + return nil, err + } + + read := req.GetRead() + + if read.GetCheckpointId() == 0 { + if err := impl.waitMinLogSequence(ctx, read.GetMinLogSequence()); err != nil { + return nil, err + } + } + + c, cleanup, err := impl.readController(ctx, read.GetCheckpointId()) + if err != nil { + return nil, err + } + defer cleanup() + + latest, versions, err := c.ListNumscriptVersions(ctx, req.GetLedger(), req.GetName()) + if err != nil { + return nil, err + } + + return &servicepb.ListNumscriptVersionsResponse{LatestVersion: latest, Versions: versions}, nil +} + func (impl *BucketServiceServerImpl) InspectIndex(ctx context.Context, req *servicepb.InspectIndexRequest) (*servicepb.InspectIndexResponse, error) { if _, err := internalauth.Authenticate(ctx, impl.authCfg, internalauth.ScopeLedgersRead); err != nil { return nil, err diff --git a/internal/adapter/http/backend_generated_test.go b/internal/adapter/http/backend_generated_test.go index d049c3a829..f65cc816b0 100644 --- a/internal/adapter/http/backend_generated_test.go +++ b/internal/adapter/http/backend_generated_test.go @@ -1253,6 +1253,46 @@ func (c *MockBackendListLogsCall) DoAndReturn(f func(context.Context, string, ui return c } +// ListNumscriptVersions mocks base method. +func (m *MockBackend) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNumscriptVersions", ctx, ledger, name) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].([]*commonpb.NumscriptVersionEntry) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ListNumscriptVersions indicates an expected call of ListNumscriptVersions. +func (mr *MockBackendMockRecorder) ListNumscriptVersions(ctx, ledger, name any) *MockBackendListNumscriptVersionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNumscriptVersions", reflect.TypeOf((*MockBackend)(nil).ListNumscriptVersions), ctx, ledger, name) + return &MockBackendListNumscriptVersionsCall{Call: call} +} + +// MockBackendListNumscriptVersionsCall wrap *gomock.Call +type MockBackendListNumscriptVersionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockBackendListNumscriptVersionsCall) Return(arg0 string, arg1 []*commonpb.NumscriptVersionEntry, arg2 error) *MockBackendListNumscriptVersionsCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockBackendListNumscriptVersionsCall) Do(f func(context.Context, string, string) (string, []*commonpb.NumscriptVersionEntry, error)) *MockBackendListNumscriptVersionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockBackendListNumscriptVersionsCall) DoAndReturn(f func(context.Context, string, string) (string, []*commonpb.NumscriptVersionEntry, error)) *MockBackendListNumscriptVersionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // ListNumscripts mocks base method. func (m *MockBackend) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) { m.ctrl.T.Helper() diff --git a/internal/adapter/http/handler.go b/internal/adapter/http/handler.go index 130e32bbb1..a07e9c8628 100644 --- a/internal/adapter/http/handler.go +++ b/internal/adapter/http/handler.go @@ -109,6 +109,7 @@ func NewHandler(logger logging.Logger, backend Backend, authCfg internalauth.Aut r.Get("/{ledgerName}/numscripts", server.handleListNumscripts) r.Get("/{ledgerName}/numscripts/{name}", server.handleGetNumscript) r.Get("/{ledgerName}/numscripts/{name}/usage", server.handleGetNumscriptUsage) + r.Get("/{ledgerName}/numscripts/{name}/versions", server.handleListNumscriptVersions) r.Get("/{ledgerName}/indexes", server.handleListLedgerIndexes) r.Get("/{ledgerName}/indexes/{canonicalId}", server.handleGetIndex) r.Get("/{ledgerName}/indexes/{canonicalId}/status", server.handleGetIndexEntryStatus) @@ -173,7 +174,6 @@ func NewHandler(logger logging.Logger, backend Backend, authCfg internalauth.Aut r.Delete("/{ledgerName}", server.handleDeleteLedger) r.Post("/{ledgerName}/promote", server.handlePromoteLedger) r.Put("/{ledgerName}/numscripts/{name}", server.handleSaveNumscript) - r.Delete("/{ledgerName}/numscripts/{name}", server.handleDeleteNumscript) r.Post("/{ledgerName}/indexes", server.handleCreateIndex) r.Delete("/{ledgerName}/indexes/{canonicalId}", server.handleDropIndex) }) diff --git a/internal/adapter/http/handlers_delete_numscript.go b/internal/adapter/http/handlers_delete_numscript.go deleted file mode 100644 index af7b6beccd..0000000000 --- a/internal/adapter/http/handlers_delete_numscript.go +++ /dev/null @@ -1,41 +0,0 @@ -package http - -import ( - "errors" - "net/http" - - "github.com/go-chi/chi/v5" - - "github.com/formancehq/ledger/v3/internal/proto/servicepb" -) - -// handleDeleteNumscript handles DELETE /{ledgerName}/numscripts/{name} to delete a numscript. -func (s *Server) handleDeleteNumscript(w http.ResponseWriter, r *http.Request) { - ledgerName, ok := requireLedgerName(w, r) - if !ok { - return - } - - name := chi.URLParam(r, "name") - if name == "" { - writeBadRequest(w, "INVALID_REQUEST", errors.New("numscript name is required")) - - return - } - - _, err := s.applyUnsigned(r.Context(), "", &servicepb.Request{ - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Ledger: ledgerName, - Name: name, - }, - }, - }) - if err != nil { - handleError(w, r, err) - - return - } - - w.WriteHeader(http.StatusNoContent) -} diff --git a/internal/adapter/http/handlers_delete_numscript_test.go b/internal/adapter/http/handlers_delete_numscript_test.go deleted file mode 100644 index d5236fe619..0000000000 --- a/internal/adapter/http/handlers_delete_numscript_test.go +++ /dev/null @@ -1,89 +0,0 @@ -package http - -import ( - "context" - "net/http" - "net/http/httptest" - "testing" - - "github.com/stretchr/testify/require" - "go.uber.org/mock/gomock" - - "github.com/formancehq/ledger/v3/internal/domain" - "github.com/formancehq/ledger/v3/internal/proto/commonpb" - "github.com/formancehq/ledger/v3/internal/proto/servicepb" -) - -func TestHandleDeleteNumscript_Success(t *testing.T) { - t.Parallel() - - backend := NewMockBackend(gomock.NewController(t)) - backend.EXPECT().Apply(gomock.Any(), gomock.Any()).DoAndReturn( - func(_ context.Context, _ *servicepb.ApplyRequest) ([]*commonpb.Log, error) { - return []*commonpb.Log{{}}, nil - }).AnyTimes() - srv := newTestServer(t, backend) - - w := httptest.NewRecorder() - r := newRequest(t, http.MethodDelete, "/ledger1/numscripts/my-script", nil, map[string]string{ - "ledgerName": "ledger1", - "name": "my-script", - }) - - srv.handleDeleteNumscript(w, r) - - require.Equal(t, http.StatusNoContent, w.Code) -} - -func TestHandleDeleteNumscript_MissingLedgerName(t *testing.T) { - t.Parallel() - - srv := newTestServer(t, NewMockBackend(gomock.NewController(t))) - - w := httptest.NewRecorder() - r := newRequest(t, http.MethodDelete, "/numscripts/my-script", nil, map[string]string{ - "ledgerName": "", - "name": "my-script", - }) - - srv.handleDeleteNumscript(w, r) - - require.Equal(t, http.StatusBadRequest, w.Code) -} - -func TestHandleDeleteNumscript_MissingName(t *testing.T) { - t.Parallel() - - srv := newTestServer(t, NewMockBackend(gomock.NewController(t))) - - w := httptest.NewRecorder() - r := newRequest(t, http.MethodDelete, "/ledger1/numscripts/", nil, map[string]string{ - "ledgerName": "ledger1", - "name": "", - }) - - srv.handleDeleteNumscript(w, r) - - require.Equal(t, http.StatusBadRequest, w.Code) -} - -func TestHandleDeleteNumscript_NotFound(t *testing.T) { - t.Parallel() - - backend := NewMockBackend(gomock.NewController(t)) - backend.EXPECT().Apply(gomock.Any(), gomock.Any()).DoAndReturn( - func(_ context.Context, _ *servicepb.ApplyRequest) ([]*commonpb.Log, error) { - return nil, &domain.ErrNumscriptNotFound{Name: "my-script"} - }).AnyTimes() - srv := newTestServer(t, backend) - - w := httptest.NewRecorder() - r := newRequest(t, http.MethodDelete, "/ledger1/numscripts/my-script", nil, map[string]string{ - "ledgerName": "ledger1", - "name": "my-script", - }) - - srv.handleDeleteNumscript(w, r) - - require.Equal(t, http.StatusNotFound, w.Code) -} diff --git a/internal/adapter/http/handlers_list_numscript_versions.go b/internal/adapter/http/handlers_list_numscript_versions.go new file mode 100644 index 0000000000..dd1c9673f2 --- /dev/null +++ b/internal/adapter/http/handlers_list_numscript_versions.go @@ -0,0 +1,54 @@ +package http + +import ( + "errors" + "net/http" + + "github.com/go-chi/chi/v5" + + "github.com/formancehq/ledger/v3/internal/proto/commonpb" +) + +// numscriptVersionEntryDTO renders one stored version for the REST API. +// createdAt reuses the proto Timestamp, whose MarshalJSON emits RFC3339. +type numscriptVersionEntryDTO struct { + Version string `json:"version"` + CreatedAt *commonpb.Timestamp `json:"createdAt,omitempty"` +} + +// numscriptVersionsDTO is the numscript history response: the current latest +// (greatest stored semver) and every stored version, highest-first. +type numscriptVersionsDTO struct { + LatestVersion string `json:"latestVersion"` + Versions []numscriptVersionEntryDTO `json:"versions"` +} + +// handleListNumscriptVersions handles GET /{ledgerName}/numscripts/{name}/versions +// to list the numscript's history. +func (s *Server) handleListNumscriptVersions(w http.ResponseWriter, r *http.Request) { + ledgerName, ok := requireLedgerName(w, r) + if !ok { + return + } + + name := chi.URLParam(r, "name") + if name == "" { + writeBadRequest(w, "INVALID_REQUEST", errors.New("numscript name is required")) + + return + } + + latest, versions, err := s.backend.ListNumscriptVersions(r.Context(), ledgerName, name) + if err != nil { + handleError(w, r, err) + + return + } + + dto := numscriptVersionsDTO{LatestVersion: latest, Versions: make([]numscriptVersionEntryDTO, len(versions))} + for i, v := range versions { + dto.Versions[i] = numscriptVersionEntryDTO{Version: v.GetVersion(), CreatedAt: v.GetCreatedAt()} + } + + writeOK(w, dto) +} diff --git a/internal/adapter/http/handlers_list_numscript_versions_test.go b/internal/adapter/http/handlers_list_numscript_versions_test.go new file mode 100644 index 0000000000..2b4d4cf7fa --- /dev/null +++ b/internal/adapter/http/handlers_list_numscript_versions_test.go @@ -0,0 +1,51 @@ +package http + +import ( + "context" + "net/http" + "net/http/httptest" + "testing" + + "github.com/stretchr/testify/require" + "go.uber.org/mock/gomock" + + "github.com/formancehq/ledger/v3/internal/proto/commonpb" +) + +func TestHandleListNumscriptVersions_Success(t *testing.T) { + t.Parallel() + + backend := NewMockBackend(gomock.NewController(t)) + backend.EXPECT().ListNumscriptVersions(gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn( + func(_ context.Context, _, _ string) (string, []*commonpb.NumscriptVersionEntry, error) { + return "2.0.0", []*commonpb.NumscriptVersionEntry{ + {Version: "2.0.0"}, + {Version: "1.0.0"}, + }, nil + }).AnyTimes() + srv := newTestServer(t, backend) + + w := httptest.NewRecorder() + r := newRequest(t, http.MethodGet, "/ledger1/numscripts/my-script/versions", nil, + map[string]string{"ledgerName": "ledger1", "name": "my-script"}) + + srv.handleListNumscriptVersions(w, r) + + require.Equal(t, http.StatusOK, w.Code) + require.Contains(t, w.Body.String(), `"latestVersion":"2.0.0"`) + require.Contains(t, w.Body.String(), `"version":"1.0.0"`) +} + +func TestHandleListNumscriptVersions_MissingName(t *testing.T) { + t.Parallel() + + srv := newTestServer(t, NewMockBackend(gomock.NewController(t))) + + w := httptest.NewRecorder() + r := newRequest(t, http.MethodGet, "/ledger1/numscripts//versions", nil, + map[string]string{"ledgerName": "ledger1", "name": ""}) + + srv.handleListNumscriptVersions(w, r) + + require.Equal(t, http.StatusBadRequest, w.Code) +} diff --git a/internal/adapter/http/handlers_list_numscripts.go b/internal/adapter/http/handlers_list_numscripts.go index f0b5024c92..5e0494d28b 100644 --- a/internal/adapter/http/handlers_list_numscripts.go +++ b/internal/adapter/http/handlers_list_numscripts.go @@ -4,7 +4,8 @@ import ( "net/http" ) -// handleListNumscripts handles GET /{ledgerName}/numscripts to list all numscripts for a ledger. +// handleListNumscripts handles GET /{ledgerName}/numscripts to list the greatest +// version of every numscript for a ledger. func (s *Server) handleListNumscripts(w http.ResponseWriter, r *http.Request) { ledgerName, ok := requireLedgerName(w, r) if !ok { diff --git a/internal/adapter/http/handlers_save_numscript.go b/internal/adapter/http/handlers_save_numscript.go index bc2a77af38..7918c5a9c5 100644 --- a/internal/adapter/http/handlers_save_numscript.go +++ b/internal/adapter/http/handlers_save_numscript.go @@ -34,7 +34,7 @@ func (s *Server) handleSaveNumscript(w http.ResponseWriter, r *http.Request) { return } - logs, err := s.applyUnsigned(r.Context(), "", &servicepb.Request{ + logs, err := s.applyUnsigned(r.Context(), r.Header.Get("Idempotency-Key"), &servicepb.Request{ Type: &servicepb.Request_SaveNumscript{ SaveNumscript: &servicepb.SaveNumscriptRequest{ Ledger: ledgerName, diff --git a/internal/application/admission/admission.go b/internal/application/admission/admission.go index 0e1d727208..95e86912df 100644 --- a/internal/application/admission/admission.go +++ b/internal/application/admission/admission.go @@ -1159,16 +1159,11 @@ func extractLedgerScopedNeeds(p *plan.Coverage, ls *raftcmdpb.LedgerScopedOrder) p.Add(dal.SubAttrPreparedQuery, domain.PreparedQueryKey{LedgerName: ledgerName, Name: payload.DeletePreparedQuery.GetName()}.Bytes()) case *raftcmdpb.LedgerScopedOrder_SaveNumscript: p.Add(dal.SubAttrLedger, ledgerBytes) + // Save reads the latest pointer (to keep it at the greatest semver) and + // the target version's content (immutability check). Version is always an + // explicit semver in this model. p.Add(dal.SubAttrNumscriptVersion, domain.NumscriptVersionKey{LedgerName: ledgerName, Name: payload.SaveNumscript.GetName()}.Bytes()) - - // For semver saves, preload the specific version content for immutability check. - version := payload.SaveNumscript.GetVersion() - if version != "" && version != "latest" { - p.Add(dal.SubAttrNumscriptContent, domain.NumscriptEntryKey{LedgerName: ledgerName, Name: payload.SaveNumscript.GetName(), Version: version}.Bytes()) - } - case *raftcmdpb.LedgerScopedOrder_DeleteNumscript: - p.Add(dal.SubAttrLedger, ledgerBytes) - p.Add(dal.SubAttrNumscriptVersion, domain.NumscriptVersionKey{LedgerName: ledgerName, Name: payload.DeleteNumscript.GetName()}.Bytes()) + p.Add(dal.SubAttrNumscriptContent, domain.NumscriptEntryKey{LedgerName: ledgerName, Name: payload.SaveNumscript.GetName(), Version: payload.SaveNumscript.GetVersion()}.Bytes()) case *raftcmdpb.LedgerScopedOrder_SaveLedgerMetadata: p.Add(dal.SubAttrLedger, ledgerBytes) for key := range payload.SaveLedgerMetadata.GetMetadata() { @@ -1583,10 +1578,24 @@ func (a *Admission) resolveScriptsAndEnrichNeeds(ctx context.Context, orders []* var scriptVars map[string]string isReference := false - // Resolve ScriptReference: load numscript content from overlay (intra-bulk) or Pebble. - var resolvedVersion string + // Resolve ScriptReference for planning only (parse, dependency discovery, + // preload). The accepted order is NOT mutated — its selector ("latest" or + // an exact semver) is audited as-is and re-resolved by the FSM at apply. + var ( + resolvedVersion string + refName string + refIsLatest bool + ) if ref := createTx.CreateTransaction.GetNumscriptReference(); ref != nil && ref.GetName() != "" { + // Executable references accept only "latest"/"" or a full semver; + // partial selectors (1, 1.2) are read-only in v3.0. + if v := ref.GetVersion(); v != "" && v != "latest" { + if _, perr := semver.Parse(v); perr != nil { + return &domain.BusinessError{Err: &domain.ErrNumscriptInvalidVersion{Version: v}} + } + } + content, rv, err := a.resolveNumscriptReference(overlay, ledgerName, ref.GetName(), ref.GetVersion()) if err != nil { return err @@ -1595,15 +1604,9 @@ func (a *Admission) resolveScriptsAndEnrichNeeds(ctx context.Context, orders []* scriptText = content scriptVars = ref.GetVars() resolvedVersion = rv + refName = ref.GetName() + refIsLatest = ref.GetVersion() == "" || ref.GetVersion() == "latest" isReference = true - - // Replace the entire NumscriptReference rather than mutating a field - // on the committed order's shared pointer. - createTx.CreateTransaction.NumscriptReference = &raftcmdpb.NumscriptReference{ - Name: ref.GetName(), - Version: resolvedVersion, - Vars: ref.GetVars(), - } } else if createTx.CreateTransaction.GetScript() != nil && createTx.CreateTransaction.GetScript().GetPlain() != "" && len(createTx.CreateTransaction.GetPostings()) == 0 { @@ -1741,18 +1744,27 @@ func (a *Admission) resolveScriptsAndEnrichNeeds(ctx context.Context, orders []* effects.recordReference(domain.TransactionReferenceKey{LedgerName: ledgerName, Reference: txRef}) } - // For references: preload the resolved content keyed by (ledger, name, version). - // The FSM resolves via NumscriptReference from the dual-gen cache. - // For inline scripts: the text stays in the order as-is, no preload needed. + // For references: preload the content for the version admission observed + // (the discovered greatest for "latest", or the exact semver). The FSM + // resolves the reference from the dual-gen cache. If a "latest" ref's + // greatest advanced since planning, the FSM's read of the newer version's + // content is not covered and surfaces as a retryable stale proposal. if isReference { - ref := createTx.CreateTransaction.GetNumscriptReference() contentKey := domain.NumscriptEntryKey{ LedgerName: ledgerName, - Name: ref.GetName(), + Name: refName, Version: resolvedVersion, }.Bytes() p.Add(dal.SubAttrNumscriptContent, contentKey) orderNeeds.Add(dal.SubAttrNumscriptContent, contentKey) + + // A "latest" selector makes the FSM read the per-name pointer to + // resolve the greatest semver; declare it so that read is covered. + if refIsLatest { + pointerKey := domain.NumscriptVersionKey{LedgerName: ledgerName, Name: refName}.Bytes() + p.Add(dal.SubAttrNumscriptVersion, pointerKey) + orderNeeds.Add(dal.SubAttrNumscriptVersion, pointerKey) + } } } @@ -2023,17 +2035,6 @@ func (a *Admission) requestToOrder(ctx context.Context, req *servicepb.Request, reqType.SaveNumscript.GetVersion(), reqType.SaveNumscript.GetContent(), ) - case *servicepb.Request_DeleteNumscript: - wrapLedgerScoped(order, &raftcmdpb.LedgerScopedOrder{ - Ledger: reqType.DeleteNumscript.GetLedger(), - Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{ - DeleteNumscript: &raftcmdpb.DeleteNumscriptOrder{ - Name: reqType.DeleteNumscript.GetName(), - }, - }, - }) - - overlay.recordNumscriptDelete(reqType.DeleteNumscript.GetLedger(), reqType.DeleteNumscript.GetName()) case *servicepb.Request_CreateQueryCheckpoint: wrapSystemScoped(order, &raftcmdpb.SystemScopedOrder{ Payload: &raftcmdpb.SystemScopedOrder_CreateQueryCheckpoint{ @@ -2274,60 +2275,62 @@ func (a *Admission) convertApplyRequest(ctx context.Context, apply *servicepb.Le return order, nil } -// requestsToOrders converts a slice of servicepb.Request to raftcmdpb.Order. -// resolveNumscriptReference resolves a numscript reference from the overlay (intra-bulk) or Pebble. +// resolveNumscriptReference resolves a numscript reference for planning (parse, +// dependency discovery, preload). It resolves against both the intra-bulk +// overlay and Pebble, always preferring the greater persisted version so an +// overlay save at a lower version can never hide a greater committed one. func (a *Admission) resolveNumscriptReference(overlay *bulkOverlay, ledgerName string, name, version string) (string, string, error) { - if content, resolvedVersion, found := a.resolveNumscriptFromOverlay(overlay, ledgerName, name, version); found { - return content, resolvedVersion, nil - } - - if overlay.numscriptLatest.IsDeleted(numscriptNameKey{Ledger: ledgerName, Name: name}) { - return "", "", &domain.BusinessError{Err: &domain.ErrNumscriptNotFound{Name: name}} - } - nsHandle, handleErr := a.store.NewDirectReadHandle() if handleErr != nil { return "", "", fmt.Errorf("creating read handle: %w", handleErr) } defer func() { _ = nsHandle.Close() }() - info, err := query.ReadNumscript(a.attrs.NumscriptVersion, a.attrs.NumscriptContent, nsHandle, ledgerName, name, version) - if err != nil { - return "", "", fmt.Errorf("reading numscript %q: %w", name, err) - } + if version == "" || version == "latest" { + // Greatest = max(in-bulk greatest, persisted greatest). + greatest := "" + if ov, ok := overlay.numscriptLatest.Get(numscriptNameKey{Ledger: ledgerName, Name: name}); ok { + greatest = ov + } - if info == nil { - return "", "", &domain.BusinessError{Err: &domain.ErrNumscriptNotFound{Name: name}} - } + persisted, perr := query.ReadNumscriptLatestVersion(a.attrs.NumscriptVersion, nsHandle, ledgerName, name) + if perr != nil { + return "", "", fmt.Errorf("reading numscript latest %q: %w", name, perr) + } - return info.GetContent(), info.GetVersion(), nil -} + if greaterSemver(persisted, greatest) { + greatest = persisted + } -// resolveNumscriptFromOverlay tries to resolve a numscript from the intra-bulk overlay. -func (a *Admission) resolveNumscriptFromOverlay(overlay *bulkOverlay, ledger, name, version string) (string, string, bool) { - if version == "" { - latestVer, ok := overlay.numscriptLatest.Get(numscriptNameKey{Ledger: ledger, Name: name}) - if !ok { - return "", "", false + if greatest == "" { + return "", "", &domain.BusinessError{Err: &domain.ErrNumscriptNotFound{Name: name}} } - content, ok := overlay.numscriptEntries.Get(numscriptEntryKey{Ledger: ledger, Name: name, Version: latestVer}) - if !ok { - return "", "", false + // Content for the greatest: overlay entry (in-bulk save) or Pebble. + if content, ok := overlay.numscriptEntries.Get(numscriptEntryKey{Ledger: ledgerName, Name: name, Version: greatest}); ok { + return content, greatest, nil } - return content, latestVer, true + version = greatest + } else if content, resolvedVersion, found := a.resolveNumscriptFromOverlay(overlay, ledgerName, name, version); found { + return content, resolvedVersion, nil } - if version == "latest" { - content, ok := overlay.numscriptEntries.Get(numscriptEntryKey{Ledger: ledger, Name: name, Version: "latest"}) - if !ok { - return "", "", false - } + info, err := query.ReadNumscript(a.attrs.NumscriptVersion, a.attrs.NumscriptContent, nsHandle, ledgerName, name, version) + if err != nil { + return "", "", fmt.Errorf("reading numscript %q: %w", name, err) + } - return content, "latest", true + if info == nil { + return "", "", &domain.BusinessError{Err: &domain.ErrNumscriptNotFound{Name: name, Version: version}} } + return info.GetContent(), info.GetVersion(), nil +} + +// resolveNumscriptFromOverlay resolves an exact or partial semver selector from +// the intra-bulk overlay. "latest"/"" are handled by resolveNumscriptReference. +func (a *Admission) resolveNumscriptFromOverlay(overlay *bulkOverlay, ledger, name, version string) (string, string, bool) { // Exact semver lookup if content, ok := overlay.numscriptEntries.Get(numscriptEntryKey{Ledger: ledger, Name: name, Version: version}); ok { return content, version, true diff --git a/internal/application/admission/admission_test.go b/internal/application/admission/admission_test.go index a0d78cc169..3a97a1e8bb 100644 --- a/internal/application/admission/admission_test.go +++ b/internal/application/admission/admission_test.go @@ -966,8 +966,10 @@ func TestExtractNeededVolumes_Numscript(t *testing.T) { Asset: "USD/2", }.Bytes()), "should discover destination account from reference vars") + // Admission no longer rewrites the reference — the audited order keeps the + // client's selector (empty = latest); only planning/discovery resolves it. ref := orders[0].GetLedgerScoped().GetApply().GetCreateTransaction().GetNumscriptReference() - require.Equal(t, "v1", ref.GetVersion()) + require.Equal(t, "", ref.GetVersion()) require.Equal(t, "users:alice", ref.GetVars()["account"]) }) diff --git a/internal/application/admission/overlay.go b/internal/application/admission/overlay.go index 90f9b17791..99ad1dd67f 100644 --- a/internal/application/admission/overlay.go +++ b/internal/application/admission/overlay.go @@ -1,6 +1,7 @@ package admission import ( + "github.com/formancehq/ledger/v3/internal/pkg/semver" "github.com/formancehq/ledger/v3/internal/proto/commonpb" ) @@ -83,18 +84,32 @@ func newBulkOverlay() *bulkOverlay { } } -// recordNumscriptSave records a numscript save in the overlay. -// Version normalization mirrors the FSM behavior: "" becomes "latest". +// recordNumscriptSave records an immutable save in the overlay and advances the +// per-name latest to the greatest semver seen so far in this bulk, mirroring the +// FSM's max-pointer maintenance. func (o *bulkOverlay) recordNumscriptSave(ledger, name, version, content string) { - if version == "" { - version = "latest" + o.numscriptEntries.Put(numscriptEntryKey{Ledger: ledger, Name: name, Version: version}, content) + + nameKey := numscriptNameKey{Ledger: ledger, Name: name} + if cur, ok := o.numscriptLatest.Get(nameKey); ok && !greaterSemver(version, cur) { + return } - o.numscriptEntries.Put(numscriptEntryKey{Ledger: ledger, Name: name, Version: version}, content) - o.numscriptLatest.Put(numscriptNameKey{Ledger: ledger, Name: name}, version) + o.numscriptLatest.Put(nameKey, version) } -// recordNumscriptDelete marks a numscript as deleted in the overlay. -func (o *bulkOverlay) recordNumscriptDelete(ledger, name string) { - o.numscriptLatest.Delete(numscriptNameKey{Ledger: ledger, Name: name}) +// greaterSemver reports whether a is a strictly greater full semver than b. +// A non-semver b (or empty) is treated as smaller so a valid save always wins. +func greaterSemver(a, b string) bool { + av, aerr := semver.Parse(a) + bv, berr := semver.Parse(b) + if aerr != nil { + return false + } + + if berr != nil { + return true + } + + return av.Compare(bv) > 0 } diff --git a/internal/application/admission/request_to_order_test.go b/internal/application/admission/request_to_order_test.go index c77e19565a..4072518176 100644 --- a/internal/application/admission/request_to_order_test.go +++ b/internal/application/admission/request_to_order_test.go @@ -205,21 +205,6 @@ func TestRequestToOrder_WrapsEveryRequestVariant(t *testing.T) { }, }, }, - { - name: "delete_numscript", - req: &servicepb.Request{Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{Ledger: ledger, Name: "tx"}, - }}, - expect: expect{ - kind: wrapLedger, - ledger: ledger, - payloadAssert: func(t *testing.T, o *raftcmdpb.Order) { - dn := mustLedgerScoped(t, o).GetDeleteNumscript() - require.NotNil(t, dn) - require.Equal(t, "tx", dn.GetName()) - }, - }, - }, { name: "apply/set_metadata_field_type", req: &servicepb.Request{Type: &servicepb.Request_SetMetadataFieldType{ diff --git a/internal/application/admission/wrapper_dispatch_test.go b/internal/application/admission/wrapper_dispatch_test.go index b8fc907b08..913933802a 100644 --- a/internal/application/admission/wrapper_dispatch_test.go +++ b/internal/application/admission/wrapper_dispatch_test.go @@ -249,21 +249,7 @@ func TestExtractLedgerScopedNeeds_CoversEveryPayloadVariant(t *testing.T) { }, }, { - name: "save_numscript_latest", - payload: &raftcmdpb.LedgerScopedOrder{ - Ledger: wrapperTestLedger, - Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{ - SaveNumscript: &raftcmdpb.SaveNumscriptOrder{Name: "tx", Version: "latest"}, - }, - }, - assert: func(t *testing.T, n *plan.Coverage) { - require.True(t, n.Has(dal.SubAttrNumscriptVersion, domain.NumscriptVersionKey{LedgerName: wrapperTestLedger, Name: "tx"}.Bytes())) - // latest does not preload a specific version content - require.Zero(t, n.Count(dal.SubAttrNumscriptContent)) - }, - }, - { - name: "save_numscript_semver", + name: "save_numscript", payload: &raftcmdpb.LedgerScopedOrder{ Ledger: wrapperTestLedger, Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{ @@ -271,7 +257,9 @@ func TestExtractLedgerScopedNeeds_CoversEveryPayloadVariant(t *testing.T) { }, }, assert: func(t *testing.T, n *plan.Coverage) { - // semver saves preload the specific (name, version) for immutability check + // Save reads the latest pointer (max maintenance) and the target + // version's content (immutability check). + require.True(t, n.Has(dal.SubAttrNumscriptVersion, domain.NumscriptVersionKey{LedgerName: wrapperTestLedger, Name: "tx"}.Bytes())) require.True(t, n.Has(dal.SubAttrNumscriptContent, domain.NumscriptEntryKey{ LedgerName: wrapperTestLedger, Name: "tx", @@ -279,18 +267,6 @@ func TestExtractLedgerScopedNeeds_CoversEveryPayloadVariant(t *testing.T) { }.Bytes())) }, }, - { - name: "delete_numscript", - payload: &raftcmdpb.LedgerScopedOrder{ - Ledger: wrapperTestLedger, - Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{ - DeleteNumscript: &raftcmdpb.DeleteNumscriptOrder{Name: "tx"}, - }, - }, - assert: func(t *testing.T, n *plan.Coverage) { - require.True(t, n.Has(dal.SubAttrNumscriptVersion, domain.NumscriptVersionKey{LedgerName: wrapperTestLedger, Name: "tx"}.Bytes())) - }, - }, { name: "save_ledger_metadata", payload: &raftcmdpb.LedgerScopedOrder{ diff --git a/internal/application/admission/wrapper_exhaustiveness_test.go b/internal/application/admission/wrapper_exhaustiveness_test.go index dbd8df6706..5388a39375 100644 --- a/internal/application/admission/wrapper_exhaustiveness_test.go +++ b/internal/application/admission/wrapper_exhaustiveness_test.go @@ -85,7 +85,6 @@ func ledgerScopedCoveredByDispatchTest(t *testing.T) map[string]struct{} { "save_ledger_metadata": {}, "delete_ledger_metadata": {}, "save_numscript": {}, - "delete_numscript": {}, "create_prepared_query": {}, "update_prepared_query": {}, "delete_prepared_query": {}, diff --git a/internal/application/check/checker.go b/internal/application/check/checker.go index 7471226380..ffd367bb81 100644 --- a/internal/application/check/checker.go +++ b/internal/application/check/checker.go @@ -31,6 +31,7 @@ import ( "github.com/formancehq/ledger/v3/internal/infra/state" "github.com/formancehq/ledger/v3/internal/pkg/bitset" "github.com/formancehq/ledger/v3/internal/pkg/cursor" + "github.com/formancehq/ledger/v3/internal/pkg/semver" "github.com/formancehq/ledger/v3/internal/proto/auditpb" "github.com/formancehq/ledger/v3/internal/proto/commonpb" "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" @@ -295,6 +296,12 @@ func (c *Checker) Check(ctx context.Context, callback func(*servicepb.CheckStore // effects (mirror fill-gap advances, numscript executions). Verified // against the stored rows by compareBoundaries. expectedBoundaries = make(map[string]*raftcmdpb.LedgerBoundaries) + // Expected numscript library projections derived from SavedNumscript / + // DeleteLedger logs. compareNumscripts diffs these against the stored + // SubAttrNumscriptContent (immutable version entries) and + // SubAttrNumscriptVersion (latest pointer = greatest stored semver). + expectedNumscriptContent = make(map[domain.NumscriptEntryKey]*commonpb.NumscriptInfo) + expectedNumscriptLatest = make(map[domain.NumscriptVersionKey]string) ) // excluded is built incrementally as SimulateEphemeralPurge decides to @@ -364,6 +371,14 @@ func (c *Checker) Check(ctx context.Context, callback func(*servicepb.CheckStore // post-archive replay applies its delta on top. c.seedExpectedFromBaseline(ctx, baselineDB, knownLedgers, expectedSchemas, rawLedgerTypes, ledgerAccountTypes, expectedBoundaries) + // Seed the numscript projections (immutable content + greatest-semver + // latest pointer) from the baseline so a post-archive out-of-order save + // does not make the checker expect a lower latest than the store holds, + // and archived immutable content stays verified. + if err := c.foldBaselineNumscripts(baselineDB, expectedNumscriptContent, expectedNumscriptLatest); err != nil { + return err + } + // Pre-populate the reversion tracking from the baseline's transaction // states so reversion invariant checks cover pre-archive transactions. if err := c.seedTxTrackingFromBaseline(baselineDB, ledgerKnownTxIDs, ledgerRevertedTxIDs); err != nil { @@ -461,6 +476,34 @@ func (c *Checker) Check(ctx context.Context, callback func(*servicepb.CheckStore delete(expectedIndexes, key) } } + + // DeleteLedger also range-deletes SubAttrNumscriptVersion / + // SubAttrNumscriptContent for the ledger (deleteLedgerData), + // so mirror the cascade on the expected numscript projections. + for key := range expectedNumscriptContent { + if key.LedgerName == name { + delete(expectedNumscriptContent, key) + } + } + + for key := range expectedNumscriptLatest { + if key.LedgerName == name { + delete(expectedNumscriptLatest, key) + } + } + } + case *commonpb.LogPayload_SavedNumscript: + // A save writes an immutable content entry and advances the latest + // pointer to the greatest stored semver (versions may be saved out + // of order). + if info := payload.SavedNumscript.GetInfo(); info != nil { + ck := domain.NumscriptEntryKey{LedgerName: info.GetLedger(), Name: info.GetName(), Version: info.GetVersion()} + expectedNumscriptContent[ck] = info + + vk := domain.NumscriptVersionKey{LedgerName: info.GetLedger(), Name: info.GetName()} + if cur, ok := expectedNumscriptLatest[vk]; !ok || numscriptVersionGreater(info.GetVersion(), cur) { + expectedNumscriptLatest[vk] = info.GetVersion() + } } case *commonpb.LogPayload_Apply: if payload.Apply != nil { @@ -676,6 +719,8 @@ func (c *Checker) Check(ctx context.Context, callback func(*servicepb.CheckStore return err } + c.compareNumscripts(snap, expectedNumscriptContent, expectedNumscriptLatest, deletedInReplay, pendingCleanupLedgers, callback) + return nil } @@ -1066,6 +1111,178 @@ func (c *Checker) compareMirrorV2LogID(reader dal.PebbleReader, chainBound *chai } } +// numscriptVersionGreater reports whether a is a strictly greater full semver +// than b. A non-semver b is treated as smaller so a valid version always wins. +func numscriptVersionGreater(a, b string) bool { + av, aerr := semver.Parse(a) + bv, berr := semver.Parse(b) + if aerr != nil { + return false + } + + if berr != nil { + return true + } + + return av.Compare(bv) > 0 +} + +// compareNumscripts verifies the numscript library projections against the +// state re-derived from the audit/log chain. SubAttrNumscriptContent holds the +// immutable per-version entries; SubAttrNumscriptVersion holds the per-name +// latest pointer (the greatest stored semver). Both are load-bearing for reads, +// listing, version history, and admission-side reference resolution, so a +// stored content row with no matching SavedNumscript, an altered content, or a +// latest pointer that is not the greatest saved semver is tampering. Under +// archiving the expected state is baseline-seeded (foldBaselineNumscripts), so — +// unlike compareIndexes — there is no archive-orphan tolerance: a stored row +// absent from both the baseline and the replay is a surplus/injected row and is +// flagged. Only the deferred-cleanup tolerance remains. +func (c *Checker) compareNumscripts( + reader dal.PebbleReader, + expectedContent map[domain.NumscriptEntryKey]*commonpb.NumscriptInfo, + expectedLatest map[domain.NumscriptVersionKey]string, + deletedInReplay map[string]struct{}, + pendingCleanupLedgers map[string]struct{}, + callback func(*servicepb.CheckStoreEvent), +) { + mismatch := func(msg, ledger string) { + callback(errorEvent(servicepb.CheckStoreErrorType_CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH, msg, 0, ledger, "", "")) + } + + // Content entries (immutable): every stored row must trace to a SavedNumscript. + contentIter, err := c.attrs.NumscriptContent.NewStreamingIter(reader, nil) + if err != nil { + mismatch(fmt.Sprintf("opening numscript content iterator: %v", err), "") + + return + } + + seenContent := make(map[domain.NumscriptEntryKey]struct{}, len(expectedContent)) + + for contentIter.Next() { + entry := contentIter.Entry() + if entry.Value == nil { + continue + } + + var key domain.NumscriptEntryKey + if err := key.Unmarshal(entry.CanonicalKey); err != nil { + mismatch(fmt.Sprintf("stored numscript content has unparsable canonical key %x: %v", entry.CanonicalKey, err), "") + + continue + } + + if _, awaiting := pendingCleanupLedgers[key.LedgerName]; awaiting { + continue + } + + seenContent[key] = struct{}{} + + exp, ok := expectedContent[key] + if !ok { + if _, deleted := deletedInReplay[key.LedgerName]; deleted { + mismatch(fmt.Sprintf("stored numscript content %q@%q for ledger %q survives a replayed DeleteLedger + completed cleanup", key.Name, key.Version, key.LedgerName), key.LedgerName) + + continue + } + + mismatch(fmt.Sprintf("stored numscript content %q@%q for ledger %q has no matching SavedNumscript in the audit chain", key.Name, key.Version, key.LedgerName), key.LedgerName) + + continue + } + + // Compare the whole NumscriptInfo, not just Content: reads and listing + // serve every field (Name, Version, Ledger, CreatedAt) straight from + // this projection, so each must match the audit-derived value. + if !entry.Value.EqualVT(exp) { + mismatch(fmt.Sprintf("numscript %q@%q for ledger %q: stored entry diverges from the audit-derived NumscriptInfo", key.Name, key.Version, key.LedgerName), key.LedgerName) + } + } + + if err := contentIter.Err(); err != nil { + mismatch(fmt.Sprintf("scanning numscript content: %v", err), "") + } + + _ = contentIter.Close() + + for key := range expectedContent { + // A baseline-seeded entry for a ledger mid-purge legitimately lingers + // on neither side in lockstep — the stored loop skips it too. + if _, awaiting := pendingCleanupLedgers[key.LedgerName]; awaiting { + continue + } + + if _, ok := seenContent[key]; !ok { + mismatch(fmt.Sprintf("audit chain expects numscript content %q@%q for ledger %q but the store has no matching entry", key.Name, key.Version, key.LedgerName), key.LedgerName) + } + } + + // Latest pointers: the stored version string must match the greatest + // saved semver derived from the SavedNumscript sequence. + versionIter, err := c.attrs.NumscriptVersion.NewStreamingIter(reader, nil) + if err != nil { + mismatch(fmt.Sprintf("opening numscript version iterator: %v", err), "") + + return + } + + seenLatest := make(map[domain.NumscriptVersionKey]struct{}, len(expectedLatest)) + + for versionIter.Next() { + entry := versionIter.Entry() + if entry.Value == nil { + continue + } + + var key domain.NumscriptVersionKey + if err := key.Unmarshal(entry.CanonicalKey); err != nil { + mismatch(fmt.Sprintf("stored numscript version pointer has unparsable canonical key %x: %v", entry.CanonicalKey, err), "") + + continue + } + + if _, awaiting := pendingCleanupLedgers[key.LedgerName]; awaiting { + continue + } + + seenLatest[key] = struct{}{} + + exp, ok := expectedLatest[key] + if !ok { + if _, deleted := deletedInReplay[key.LedgerName]; deleted { + mismatch(fmt.Sprintf("stored numscript latest pointer for %q on ledger %q survives a replayed DeleteLedger + completed cleanup", key.Name, key.LedgerName), key.LedgerName) + + continue + } + + mismatch(fmt.Sprintf("stored numscript latest pointer for %q on ledger %q has no matching SavedNumscript in the audit chain", key.Name, key.LedgerName), key.LedgerName) + + continue + } + + if entry.Value.GetVersion() != exp { + mismatch(fmt.Sprintf("numscript %q on ledger %q: stored latest pointer %q diverges from the audit-derived %q", key.Name, key.LedgerName, entry.Value.GetVersion(), exp), key.LedgerName) + } + } + + if err := versionIter.Err(); err != nil { + mismatch(fmt.Sprintf("scanning numscript version pointers: %v", err), "") + } + + _ = versionIter.Close() + + for key := range expectedLatest { + if _, awaiting := pendingCleanupLedgers[key.LedgerName]; awaiting { + continue + } + + if _, ok := seenLatest[key]; !ok { + mismatch(fmt.Sprintf("audit chain expects a numscript latest pointer for %q on ledger %q but the store has no matching entry", key.Name, key.LedgerName), key.LedgerName) + } + } +} + // excludedVolumesSet maps ledger name to a set of (account, asset) tuples // that legitimately diverge between the replay store and the live Pebble // store. The set is populated incrementally by the replay-time @@ -3167,6 +3384,68 @@ func (c *Checker) foldBaselineReferences( return true, nil } +// foldBaselineNumscripts seeds the expected numscript projections from the +// boundary-time baseline snapshot: the immutable per-version content entries +// (SubAttrNumscriptContent) and the per-name latest pointer +// (SubAttrNumscriptVersion, the greatest stored semver). Under archiving the +// SavedNumscript logs that produced pre-archive versions are purged, so without +// this seed the post-archive replay would rebuild the expected state from the +// delta alone: an out-of-order save (e.g. a delta 1.0.0 on top of an archived +// 2.0.0) would make the checker expect a lower latest than the store correctly +// holds — a false NUMSCRIPT_MISMATCH — and an archived immutable content entry +// would go unverified. The delta replay layers on top with the same +// greatest-wins rule the FSM uses. +// +// baselineDB=nil short-circuits (no archived data). +func (c *Checker) foldBaselineNumscripts( + baselineDB *pebble.DB, + expectedContent map[domain.NumscriptEntryKey]*commonpb.NumscriptInfo, + expectedLatest map[domain.NumscriptVersionKey]string, +) error { + if baselineDB == nil { + return nil + } + + contentIter, err := c.attrs.NumscriptContent.NewStreamingIter(baselineDB, nil) + if err != nil { + return fmt.Errorf("iterating baseline numscript content: %w", err) + } + + for contentIter.Next() { + entry := contentIter.Entry() + if entry.Value == nil { + continue + } + + var key domain.NumscriptEntryKey + if err := key.Unmarshal(entry.CanonicalKey); err != nil { + continue + } + + expectedContent[key] = entry.Value + + // Derive the latest pointer from the content rows — the greatest stored + // semver — rather than trusting the baseline's stored pointer, which + // could itself have drifted before the archive boundary. Mirrors the + // live FSM, which always advances latest to the greatest content; the + // delta replay then advances it further with the same greatest-wins rule. + vk := domain.NumscriptVersionKey{LedgerName: key.LedgerName, Name: key.Name} + if cur, ok := expectedLatest[vk]; !ok || numscriptVersionGreater(key.Version, cur) { + expectedLatest[vk] = key.Version + } + } + + if err := contentIter.Close(); err != nil { + return fmt.Errorf("closing baseline numscript content iterator: %w", err) + } + + if err := contentIter.Err(); err != nil { + return fmt.Errorf("baseline numscript content iterator error: %w", err) + } + + return nil +} + // foldBaselineChainState seeds chainBound.reverted / metadata / // accountTypes / ledgerCreationSeen / nextTxID from the baseline // snapshot. Sibling of foldBaselineReferences — closes the archive- diff --git a/internal/application/check/checker_numscript_test.go b/internal/application/check/checker_numscript_test.go new file mode 100644 index 0000000000..b9ee5b0ea3 --- /dev/null +++ b/internal/application/check/checker_numscript_test.go @@ -0,0 +1,134 @@ +package check + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/formancehq/ledger/v3/internal/domain" + "github.com/formancehq/ledger/v3/internal/proto/commonpb" + "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" + "github.com/formancehq/ledger/v3/internal/proto/servicepb" +) + +const numscriptTestContent = "send [USD 1] (source = @world destination = @x)" + +func saveNumscriptOrder(ledger, name, content, version string) *raftcmdpb.Order { + return &raftcmdpb.Order{Type: &raftcmdpb.Order_LedgerScoped{LedgerScoped: &raftcmdpb.LedgerScopedOrder{ + Ledger: ledger, + Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{SaveNumscript: &raftcmdpb.SaveNumscriptOrder{Name: name, Content: content, Version: version}}, + }}} +} + +func tamperNumscriptContent(t *testing.T, e *testEngine, info *commonpb.NumscriptInfo) { + t.Helper() + + batch := e.store.OpenWriteSession() + key := domain.NumscriptEntryKey{LedgerName: info.GetLedger(), Name: info.GetName(), Version: info.GetVersion()} + _, err := e.attrs.NumscriptContent.Set(batch, key.Bytes(), info) + require.NoError(t, err) + require.NoError(t, batch.Commit()) +} + +func dropNumscriptContent(t *testing.T, e *testEngine, ledger, name, version string) { + t.Helper() + + batch := e.store.OpenWriteSession() + key := domain.NumscriptEntryKey{LedgerName: ledger, Name: name, Version: version} + require.NoError(t, e.attrs.NumscriptContent.Delete(batch, key.Bytes())) + require.NoError(t, batch.Commit()) +} + +func tamperNumscriptLatest(t *testing.T, e *testEngine, ledger, name, version string) { + t.Helper() + + batch := e.store.OpenWriteSession() + key := domain.NumscriptVersionKey{LedgerName: ledger, Name: name} + _, err := e.attrs.NumscriptVersion.Set(batch, key.Bytes(), &commonpb.NumscriptVersionValue{Version: version}) + require.NoError(t, err) + require.NoError(t, batch.Commit()) +} + +func numscriptMismatches(errs []*servicepb.CheckStoreError) []*servicepb.CheckStoreError { + var out []*servicepb.CheckStoreError + for _, e := range errs { + if e.GetErrorType() == servicepb.CheckStoreErrorType_CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH { + out = append(out, e) + } + } + + return out +} + +// TestCheckerNumscript_CleanProjectionPasses: saves with their matching +// projection (greatest-semver pointer) yield no numscript mismatch. +func TestCheckerNumscript_CleanProjectionPasses(t *testing.T) { + t.Parallel() + + e := newTestEngine(t) + e.processAndCommit(createLedgerOrder("main")) + // Save out of order: pointer must end at the greatest (2.0.0). + e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "2.0.0")) + e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "1.0.0")) + + require.Empty(t, numscriptMismatches(collectCheckErrors(t, e.store, e.attrs))) +} + +// TestCheckerNumscript_ContentTamperDetected: altered stored content diverges +// from the audit-derived content. +func TestCheckerNumscript_ContentTamperDetected(t *testing.T) { + t.Parallel() + + e := newTestEngine(t) + e.processAndCommit(createLedgerOrder("main")) + logs := e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "1.0.0")) + + tampered := logs[0].GetPayload().GetSavedNumscript().GetInfo().CloneVT() + tampered.Content = "send [USD 999] (source = @world destination = @evil)" + tamperNumscriptContent(t, e, tampered) + + require.NotEmpty(t, numscriptMismatches(collectCheckErrors(t, e.store, e.attrs))) +} + +// TestCheckerNumscript_PointerDriftDetected: the stored latest pointer is not +// the greatest saved semver. +func TestCheckerNumscript_PointerDriftDetected(t *testing.T) { + t.Parallel() + + e := newTestEngine(t) + e.processAndCommit(createLedgerOrder("main")) + e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "1.0.0")) + e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "2.0.0")) + + // Audit-derived greatest is 2.0.0; roll the pointer back to 1.0.0. + tamperNumscriptLatest(t, e, "main", "pay", "1.0.0") + + require.NotEmpty(t, numscriptMismatches(collectCheckErrors(t, e.store, e.attrs))) +} + +// TestCheckerNumscript_MissingContentDetected: an immutable content entry the +// SavedNumscript log requires is gone. +func TestCheckerNumscript_MissingContentDetected(t *testing.T) { + t.Parallel() + + e := newTestEngine(t) + e.processAndCommit(createLedgerOrder("main")) + e.processAndCommit(saveNumscriptOrder("main", "pay", numscriptTestContent, "1.0.0")) + + dropNumscriptContent(t, e, "main", "pay", "1.0.0") + + require.NotEmpty(t, numscriptMismatches(collectCheckErrors(t, e.store, e.attrs))) +} + +// TestCheckerNumscript_ExtraContentDetected: a stored content row that no +// SavedNumscript log accounts for. +func TestCheckerNumscript_ExtraContentDetected(t *testing.T) { + t.Parallel() + + e := newTestEngine(t) + e.processAndCommit(createLedgerOrder("main")) + + tamperNumscriptContent(t, e, &commonpb.NumscriptInfo{Name: "ghost", Version: "1.0.0", Content: numscriptTestContent, Ledger: "main"}) + + require.NotEmpty(t, numscriptMismatches(collectCheckErrors(t, e.store, e.attrs))) +} diff --git a/internal/application/check/checker_test.go b/internal/application/check/checker_test.go index d477a3cb83..25fba2f691 100644 --- a/internal/application/check/checker_test.go +++ b/internal/application/check/checker_test.go @@ -62,6 +62,8 @@ type testEngine struct { references map[string]*commonpb.TransactionReferenceValue transactionStates map[string]*commonpb.TransactionState reversions map[string]*bitset.Bitset + numscriptContent map[string]*commonpb.NumscriptInfo // key = NumscriptEntryKey bytes + numscriptLatest map[string]string // key = NumscriptVersionKey bytes currentOpenChapter *commonpb.Chapter closingChapters []*commonpb.Chapter nextLedgerID uint32 @@ -102,6 +104,8 @@ func newTestEngine(t *testing.T) *testEngine { references: make(map[string]*commonpb.TransactionReferenceValue), transactionStates: make(map[string]*commonpb.TransactionState), reversions: make(map[string]*bitset.Bitset), + numscriptContent: make(map[string]*commonpb.NumscriptInfo), + numscriptLatest: make(map[string]string), nextChapterID: 1, nextAuditSequenceID: 1, raftIndex: 1, @@ -231,6 +235,19 @@ func (e *testEngine) processAndCommit(orders ...*raftcmdpb.Order) []*commonpb.Lo require.NoError(e.t, err) } + // Persist the numscript projections (content + latest pointers) that the + // FSM would write via PutNumscript / SetNumscriptLatestVersion. Full + // re-persist each commit is idempotent and the maps are tiny in tests. + for keyStr, info := range e.numscriptContent { + _, err := e.attrs.NumscriptContent.Set(batch, []byte(keyStr), info) + require.NoError(e.t, err) + } + + for keyStr, version := range e.numscriptLatest { + _, err := e.attrs.NumscriptVersion.Set(batch, []byte(keyStr), &commonpb.NumscriptVersionValue{Version: version}) + require.NoError(e.t, err) + } + // For deleted ledgers, remove boundary from in-memory state (blocks // subsequent operations) but keep all other data — it stays in Pebble // until the purge cycle cleans it up. @@ -696,20 +713,34 @@ func (s *scopeImpl) UpdateChapter(_ *commonpb.Chapter) {} func (s *scopeImpl) GetPreparedQuery(_ string, _ string) (commonpb.PreparedQueryReader, error) { return nil, nil } -func (s *scopeImpl) PutPreparedQuery(_ string, _ *commonpb.PreparedQuery) {} -func (s *scopeImpl) DeletePreparedQuery(_ string, _ string) {} -func (s *scopeImpl) GetNumscriptLatestVersion(_ string, _ string) (string, error) { return "", nil } -func (s *scopeImpl) NumscriptVersionExists(_ string, _, _ string) (bool, error) { - return false, nil +func (s *scopeImpl) PutPreparedQuery(_ string, _ *commonpb.PreparedQuery) {} +func (s *scopeImpl) DeletePreparedQuery(_ string, _ string) {} +func (s *scopeImpl) GetNumscriptLatestVersion(ledger, name string) (string, error) { + return s.engine.numscriptLatest[string(domain.NumscriptVersionKey{LedgerName: ledger, Name: name}.Bytes())], nil +} +func (s *scopeImpl) NumscriptVersionExists(ledger, name, version string) (bool, error) { + _, ok := s.engine.numscriptContent[string(domain.NumscriptEntryKey{LedgerName: ledger, Name: name, Version: version}.Bytes())] + + return ok, nil +} +func (s *scopeImpl) PutNumscript(ledger string, info *commonpb.NumscriptInfo) { + s.engine.numscriptContent[string(domain.NumscriptEntryKey{LedgerName: ledger, Name: info.GetName(), Version: info.GetVersion()}.Bytes())] = info + s.engine.numscriptLatest[string(domain.NumscriptVersionKey{LedgerName: ledger, Name: info.GetName()}.Bytes())] = info.GetVersion() +} +func (s *scopeImpl) SetNumscriptLatestVersion(ledger, name, version string) { + s.engine.numscriptLatest[string(domain.NumscriptVersionKey{LedgerName: ledger, Name: name}.Bytes())] = version } -func (s *scopeImpl) PutNumscript(_ string, _ *commonpb.NumscriptInfo) {} -func (s *scopeImpl) DeleteNumscriptLatest(_ string, _ string) {} func (s *scopeImpl) GetNextQueryCheckpointID() uint64 { return 1 } func (s *scopeImpl) IncrementNextQueryCheckpointID() uint64 { return 1 } func (s *scopeImpl) SaveQueryCheckpoint(_ *raftcmdpb.QueryCheckpointState) {} func (s *scopeImpl) DeleteQueryCheckpoint(_ uint64) {} -func (s *scopeImpl) ResolveNumscriptContent(_ string, _, _ string) (commonpb.NumscriptInfoReader, error) { - return nil, nil +func (s *scopeImpl) ResolveNumscriptContent(ledger, name, version string) (commonpb.NumscriptInfoReader, error) { + info, ok := s.engine.numscriptContent[string(domain.NumscriptEntryKey{LedgerName: ledger, Name: name, Version: version}.Bytes())] + if !ok { + return nil, nil + } + + return info.AsReader(), nil } // Index registry stubs — the check engine doesn't exercise CreateIndex / diff --git a/internal/application/ctrl/controller.go b/internal/application/ctrl/controller.go index ebafb97fce..1510de20aa 100644 --- a/internal/application/ctrl/controller.go +++ b/internal/application/ctrl/controller.go @@ -78,6 +78,7 @@ type Controller interface { // Numscript library operations GetNumscript(ctx context.Context, ledger, name string, version string) (*commonpb.NumscriptInfo, error) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) + ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) // GetTemplateUsage returns the invocation counter and last-used timestamp // for a Numscript template. Reads from the usagebuilder side-store, so diff --git a/internal/application/ctrl/controller_default.go b/internal/application/ctrl/controller_default.go index eaef052544..91df06fcd2 100644 --- a/internal/application/ctrl/controller_default.go +++ b/internal/application/ctrl/controller_default.go @@ -1924,7 +1924,7 @@ func (ctrl *DefaultController) GetTemplateUsage(ctx context.Context, ledger, nam return usage, nil } -// ListNumscripts returns the latest version of all numscripts for a ledger. +// ListNumscripts returns the greatest version of every numscript for a ledger. func (ctrl *DefaultController) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) { handle, err := ctrl.store.NewReadHandle() if err != nil { @@ -1941,6 +1941,24 @@ func (ctrl *DefaultController) ListNumscripts(ctx context.Context, ledger string return query.ReadAllNumscripts(ctrl.attrs.NumscriptVersion, ctrl.attrs.NumscriptContent, handle, ledgerInfo.GetName()) } +// ListNumscriptVersions returns a numscript's current latest (greatest stored +// semver) and every stored version. +func (ctrl *DefaultController) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + handle, err := ctrl.store.NewReadHandle() + if err != nil { + return "", nil, fmt.Errorf("creating read handle: %w", err) + } + + defer func() { _ = handle.Close() }() + + ledgerInfo, err := query.GetLedgerByName(ctx, handle, ledger) + if err != nil { + return "", nil, err + } + + return query.ReadAllNumscriptVersions(ctrl.attrs.NumscriptVersion, ctrl.attrs.NumscriptContent, handle, ledgerInfo.GetName(), name) +} + func (ctrl *DefaultController) GetChapterSchedule(_ context.Context) (string, error) { handle, err := ctrl.store.NewReadHandle() if err != nil { diff --git a/internal/application/ctrl/controller_generated_test.go b/internal/application/ctrl/controller_generated_test.go index cf45ef096a..7b364aa43d 100644 --- a/internal/application/ctrl/controller_generated_test.go +++ b/internal/application/ctrl/controller_generated_test.go @@ -450,6 +450,22 @@ func (mr *MockControllerMockRecorder) ListLogs(ctx, ledgerName, afterSequence, p return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogs", reflect.TypeOf((*MockController)(nil).ListLogs), ctx, ledgerName, afterSequence, pageSize, filter) } +// ListNumscriptVersions mocks base method. +func (m *MockController) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNumscriptVersions", ctx, ledger, name) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].([]*commonpb.NumscriptVersionEntry) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ListNumscriptVersions indicates an expected call of ListNumscriptVersions. +func (mr *MockControllerMockRecorder) ListNumscriptVersions(ctx, ledger, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNumscriptVersions", reflect.TypeOf((*MockController)(nil).ListNumscriptVersions), ctx, ledger, name) +} + // ListNumscripts mocks base method. func (m *MockController) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) { m.ctrl.T.Helper() diff --git a/internal/application/ctrl/ctrlmock/controller_generated.go b/internal/application/ctrl/ctrlmock/controller_generated.go index 5f84baef77..596c3ab0c4 100644 --- a/internal/application/ctrl/ctrlmock/controller_generated.go +++ b/internal/application/ctrl/ctrlmock/controller_generated.go @@ -451,6 +451,22 @@ func (mr *MockControllerMockRecorder) ListLogs(ctx, ledgerName, afterSequence, p return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListLogs", reflect.TypeOf((*MockController)(nil).ListLogs), ctx, ledgerName, afterSequence, pageSize, filter) } +// ListNumscriptVersions mocks base method. +func (m *MockController) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListNumscriptVersions", ctx, ledger, name) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].([]*commonpb.NumscriptVersionEntry) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ListNumscriptVersions indicates an expected call of ListNumscriptVersions. +func (mr *MockControllerMockRecorder) ListNumscriptVersions(ctx, ledger, name any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNumscriptVersions", reflect.TypeOf((*MockController)(nil).ListNumscriptVersions), ctx, ledger, name) +} + // ListNumscripts mocks base method. func (m *MockController) ListNumscripts(ctx context.Context, ledger string) ([]*commonpb.NumscriptInfo, error) { m.ctrl.T.Helper() diff --git a/internal/bootstrap/controller_routed.go b/internal/bootstrap/controller_routed.go index 904fa31b69..f5d9a8a212 100644 --- a/internal/bootstrap/controller_routed.go +++ b/internal/bootstrap/controller_routed.go @@ -370,6 +370,15 @@ func (b *RoutedController) GetTemplateUsage(ctx context.Context, ledger, name st return c.GetTemplateUsage(ctx, ledger, name) } +func (b *RoutedController) ListNumscriptVersions(ctx context.Context, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + c, _, err := b.readCtrl(ctx) + if err != nil { + return "", nil, err + } + + return c.ListNumscriptVersions(ctx, ledger, name) +} + func (b *RoutedController) GetChapterSchedule(ctx context.Context) (string, error) { c, _, err := b.readCtrl(ctx) if err != nil { diff --git a/internal/domain/audit_order_type.go b/internal/domain/audit_order_type.go index 55e905f944..984f3dac19 100644 --- a/internal/domain/audit_order_type.go +++ b/internal/domain/audit_order_type.go @@ -34,8 +34,6 @@ func ledgerScopedOrderType(o *raftcmdpb.LedgerScopedOrder) string { return "delete_ledger_metadata" case *raftcmdpb.LedgerScopedOrder_SaveNumscript: return "save_numscript" - case *raftcmdpb.LedgerScopedOrder_DeleteNumscript: - return "delete_numscript" case *raftcmdpb.LedgerScopedOrder_CreatePreparedQuery: return "create_prepared_query" case *raftcmdpb.LedgerScopedOrder_UpdatePreparedQuery: diff --git a/internal/domain/audit_order_type_test.go b/internal/domain/audit_order_type_test.go index 5307bdecf4..deb9a18d12 100644 --- a/internal/domain/audit_order_type_test.go +++ b/internal/domain/audit_order_type_test.go @@ -165,13 +165,6 @@ func TestAuditOrderType(t *testing.T) { }}, want: "save_numscript", }, - { - name: "delete numscript", - order: &raftcmdpb.Order{Type: &raftcmdpb.Order_LedgerScoped{ - LedgerScoped: &raftcmdpb.LedgerScopedOrder{Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{}}, - }}, - want: "delete_numscript", - }, { name: "create prepared query", order: &raftcmdpb.Order{Type: &raftcmdpb.Order_LedgerScoped{ diff --git a/internal/domain/errors.go b/internal/domain/errors.go index 3dcf458f34..637c81a325 100644 --- a/internal/domain/errors.go +++ b/internal/domain/errors.go @@ -1042,15 +1042,32 @@ func (e *ErrInvalidReceipt) Metadata() map[string]string { } // ErrNumscriptNotFound — referenced numscript does not exist in the library. +// Version is optional: set it when a specific version was requested (restore, +// exact get) and left empty when the numscript name itself is unknown. type ErrNumscriptNotFound struct { - Name string + Name string + Version string +} + +func (e *ErrNumscriptNotFound) Error() string { + if e.Version != "" { + return fmt.Sprintf("numscript not found: %s version %s", e.Name, e.Version) + } + + return "numscript not found: " + e.Name } +func (*ErrNumscriptNotFound) Reason() string { return ErrReasonNumscriptNotFound } +func (e *ErrNumscriptNotFound) Metadata() map[string]string { + m := map[string]string{"name": e.Name} + if e.Version != "" { + m["version"] = e.Version + } -func (e *ErrNumscriptNotFound) Error() string { return "numscript not found: " + e.Name } -func (*ErrNumscriptNotFound) Reason() string { return ErrReasonNumscriptNotFound } -func (e *ErrNumscriptNotFound) Metadata() map[string]string { return map[string]string{"name": e.Name} } + return m +} -// ErrNumscriptVersionAlreadyExists — saving with a semver version that already exists. +// ErrNumscriptVersionAlreadyExists — saving a semver version that already +// exists on a live numscript. The immutable content cannot be overwritten. type ErrNumscriptVersionAlreadyExists struct { Name string Version string diff --git a/internal/domain/keys.go b/internal/domain/keys.go index 398b0ce44a..77bc54d3a7 100644 --- a/internal/domain/keys.go +++ b/internal/domain/keys.go @@ -453,6 +453,18 @@ func (k NumscriptVersionKey) Bytes() []byte { return k.AppendBytes(nil) } +func (k *NumscriptVersionKey) Unmarshal(d []byte) error { + name, rest, err := readLedgerName(d) + if err != nil { + return fmt.Errorf("invalid numscript version key bytes: %w", err) + } + + k.LedgerName = name + k.Name = string(rest) + + return nil +} + // NumscriptEntryKey uniquely identifies a specific numscript version entry scoped to a ledger. type NumscriptEntryKey struct { LedgerName string @@ -473,12 +485,25 @@ func (k NumscriptEntryKey) Bytes() []byte { return k.AppendBytes(nil) } -const ( - // NumscriptVersionTagSemver is the tag byte for semver-encoded numscript entries. - NumscriptVersionTagSemver byte = 0x00 - // NumscriptVersionTagLatest is the tag byte for the "latest" numscript slot. - NumscriptVersionTagLatest byte = 0x01 -) +func (k *NumscriptEntryKey) Unmarshal(d []byte) error { + ledger, rest, err := readLedgerName(d) + if err != nil { + return fmt.Errorf("invalid numscript entry key bytes: %w", err) + } + + // rest is [name][0x00][version]; names are validated printable ASCII, so + // the first NUL byte is the name/version separator. + before, after, ok := bytes.Cut(rest, []byte{0x00}) + if !ok { + return errors.New("invalid numscript entry key bytes: missing name/version separator") + } + + k.LedgerName = ledger + k.Name = string(before) + k.Version = string(after) + + return nil +} // IndexKey identifies an entry in the bucket-scoped index registry. // diff --git a/internal/domain/processing/processor.go b/internal/domain/processing/processor.go index 4feacda0a4..df09ca9a2b 100644 --- a/internal/domain/processing/processor.go +++ b/internal/domain/processing/processor.go @@ -469,8 +469,6 @@ func processLedgerScoped(ls *raftcmdpb.LedgerScopedOrder, ctx *Context) (*common return processDeleteLedgerMetadata(ledger, payload.DeleteLedgerMetadata, ctx) case *raftcmdpb.LedgerScopedOrder_SaveNumscript: return processSaveNumscript(ledger, payload.SaveNumscript, ctx) - case *raftcmdpb.LedgerScopedOrder_DeleteNumscript: - return processDeleteNumscript(ledger, payload.DeleteNumscript, ctx) case *raftcmdpb.LedgerScopedOrder_CreatePreparedQuery: return processCreatePreparedQuery(ledger, payload.CreatePreparedQuery, ctx) case *raftcmdpb.LedgerScopedOrder_UpdatePreparedQuery: diff --git a/internal/domain/processing/processor_dispatch_test.go b/internal/domain/processing/processor_dispatch_test.go index 12ff88b6ed..3c29dd10ab 100644 --- a/internal/domain/processing/processor_dispatch_test.go +++ b/internal/domain/processing/processor_dispatch_test.go @@ -90,15 +90,6 @@ func TestProcessOrder_DispatchEveryLedgerScopedVariant(t *testing.T) { }, }, }, - { - "delete_numscript", - &raftcmdpb.LedgerScopedOrder{ - Ledger: ledger, - Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{ - DeleteNumscript: &raftcmdpb.DeleteNumscriptOrder{Name: "n"}, - }, - }, - }, { "create_prepared_query", &raftcmdpb.LedgerScopedOrder{ diff --git a/internal/domain/processing/processor_numscript_library.go b/internal/domain/processing/processor_numscript_library.go index 147bb1ee3b..c0c3763a1e 100644 --- a/internal/domain/processing/processor_numscript_library.go +++ b/internal/domain/processing/processor_numscript_library.go @@ -7,6 +7,9 @@ import ( "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" ) +// processSaveNumscript appends an immutable version to the library. The version +// must be an explicit full semver; content entries are immutable, and the +// per-name latest pointer is maintained as the greatest stored semver. func processSaveNumscript(ledger string, order *raftcmdpb.SaveNumscriptOrder, ctx *Context) (*commonpb.LogPayload, domain.Describable) { s := ctx.Scope @@ -24,47 +27,54 @@ func processSaveNumscript(ledger string, order *raftcmdpb.SaveNumscriptOrder, ct return nil, &domain.ErrNumscriptParse{Details: err.Error()} } + // Save requires an explicit full semver — no "latest", no partial selectors. + version, err := semver.Parse(order.GetVersion()) + if err != nil { + return nil, &domain.ErrNumscriptInvalidVersion{Version: order.GetVersion()} + } + if _, loadErr := loadLedger(s, ledger); loadErr != nil { return nil, loadErr } - version := order.GetVersion() - if version == "" { - // Default: treat as "latest" - version = "latest" + // Immutable: a stored version can never be overwritten. + exists, existsErr := s.NumscriptVersionExists(ledger, order.GetName(), order.GetVersion()) + if existsErr != nil { + return nil, &domain.ErrStorageOperation{Operation: "checking numscript version existence", Cause: existsErr} } - var resolvedVersion string - - if version == "latest" { - // "latest" is its own version slot, always overwritable - resolvedVersion = "latest" - } else if _, err := semver.Parse(version); err == nil { - // Semver versions are immutable — check the specific version doesn't already exist - exists, err := s.NumscriptVersionExists(ledger, order.GetName(), version) - if err != nil { - return nil, &domain.ErrStorageOperation{Operation: "checking numscript version existence", Cause: err} - } - - if exists { - return nil, &domain.ErrNumscriptVersionAlreadyExists{Name: order.GetName(), Version: version} - } + if exists { + return nil, &domain.ErrNumscriptVersionAlreadyExists{Name: order.GetName(), Version: order.GetVersion()} + } - resolvedVersion = version - } else { - return nil, &domain.ErrNumscriptInvalidVersion{Version: version} + // Read the current greatest BEFORE PutNumscript overwrites the pointer, so + // the max comparison sees the pre-existing pointer rather than the value we + // are about to write. + current, curErr := s.GetNumscriptLatestVersion(ledger, order.GetName()) + if curErr != nil { + return nil, &domain.ErrStorageOperation{Operation: "getting numscript latest version", Cause: curErr} } info := &commonpb.NumscriptInfo{ Name: order.GetName(), Content: order.GetContent(), - Version: resolvedVersion, + Version: order.GetVersion(), CreatedAt: s.GetDate().Mutate(), Ledger: ledger, } + // Write the immutable content and advance the latest pointer to the greatest + // stored semver. Any unused semver may be added out of order, so the pointer + // is max(current, new): PutNumscript sets it to the new version, then we + // restore a greater pre-existing pointer if one existed. s.PutNumscript(ledger, info) + if current != "" { + if cur, parseErr := semver.Parse(current); parseErr == nil && cur.Compare(version) > 0 { + s.SetNumscriptLatestVersion(ledger, order.GetName(), current) + } + } + return &commonpb.LogPayload{ Type: &commonpb.LogPayload_SavedNumscript{ SavedNumscript: &commonpb.SavedNumscriptLog{ @@ -73,35 +83,3 @@ func processSaveNumscript(ledger string, order *raftcmdpb.SaveNumscriptOrder, ct }, }, nil } - -func processDeleteNumscript(ledger string, order *raftcmdpb.DeleteNumscriptOrder, ctx *Context) (*commonpb.LogPayload, domain.Describable) { - s := ctx.Scope - - if err := domain.ValidateNumscriptName(order.GetName()); err != nil { - return nil, err - } - - if _, loadErr := loadLedger(s, ledger); loadErr != nil { - return nil, loadErr - } - - currentVersion, err := s.GetNumscriptLatestVersion(ledger, order.GetName()) - if err != nil { - return nil, &domain.ErrStorageOperation{Operation: "getting numscript latest version", Cause: err} - } - - if currentVersion == "" { - return nil, &domain.ErrNumscriptNotFound{Name: order.GetName()} - } - - s.DeleteNumscriptLatest(ledger, order.GetName()) - - return &commonpb.LogPayload{ - Type: &commonpb.LogPayload_DeletedNumscript{ - DeletedNumscript: &commonpb.DeletedNumscriptLog{ - Name: order.GetName(), - Ledger: ledger, - }, - }, - }, nil -} diff --git a/internal/domain/processing/processor_numscript_library_test.go b/internal/domain/processing/processor_numscript_library_test.go index 48ea03d1ff..12eeb8f12c 100644 --- a/internal/domain/processing/processor_numscript_library_test.go +++ b/internal/domain/processing/processor_numscript_library_test.go @@ -7,12 +7,20 @@ import ( "go.uber.org/mock/gomock" "github.com/formancehq/ledger/v3/internal/domain" + "github.com/formancehq/ledger/v3/internal/proto/commonpb" "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" ) -// TestProcessSaveNumscript_RejectsInvalidNames pins the validator branch on -// the save path. Numscript names land in the `x-next-cursor` trailer of -// `numscripts list`, so they must be HTTP/2-header-safe (printable ASCII). +const validNumscriptContent = "send [USD 1] (source = @world destination = @x)" + +func saveNumscriptOrder(ledger, name, content, version string) *raftcmdpb.Order { + return &raftcmdpb.Order{Type: &raftcmdpb.Order_LedgerScoped{LedgerScoped: &raftcmdpb.LedgerScopedOrder{ + Ledger: ledger, + Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{SaveNumscript: &raftcmdpb.SaveNumscriptOrder{Name: name, Content: content, Version: version}}, + }}} +} + +// TestProcessSaveNumscript_RejectsInvalidNames pins the validator branch. func TestProcessSaveNumscript_RejectsInvalidNames(t *testing.T) { t.Parallel() @@ -31,75 +39,84 @@ func TestProcessSaveNumscript_RejectsInvalidNames(t *testing.T) { t.Parallel() ctrl := gomock.NewController(t) - defer ctrl.Finish() - mockStore := NewMockScope(ctrl) processor, err := NewRequestProcessor(nil, 0) require.NoError(t, err) - // Validator must short-circuit before any store interaction — - // gomock fails the test if PutNumscript/GetLedger is hit. - - order := &raftcmdpb.Order{ - Type: &raftcmdpb.Order_LedgerScoped{ - LedgerScoped: &raftcmdpb.LedgerScopedOrder{ - Ledger: "main", - Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{ - SaveNumscript: &raftcmdpb.SaveNumscriptOrder{ - Name: tt.input, - Content: "send [USD 1] (source = @world allocate { @bob })"}, - }, - }, - }, - } - - result, err := processor.ProcessOrder(order, mockStore) - require.Error(t, err) - require.ErrorIs(t, err, tt.wantErr) + result, perr := processor.ProcessOrder(saveNumscriptOrder("main", tt.input, validNumscriptContent, "1.0.0"), mockStore) + require.Error(t, perr) + require.ErrorIs(t, perr, tt.wantErr) require.Nil(t, result) }) } } -func TestProcessDeleteNumscript_RejectsInvalidNames(t *testing.T) { +// TestProcessSaveNumscript_RequiresExplicitSemver rejects "", "latest" and +// partial selectors — save is explicit-semver only. +func TestProcessSaveNumscript_RequiresExplicitSemver(t *testing.T) { t.Parallel() - tests := []struct { - name string - input string - wantErr domain.Describable - }{ - {name: "empty", input: "", wantErr: domain.ErrNumscriptNameRequired}, - {name: "with control byte", input: "name\x01", wantErr: domain.ErrNumscriptNameInvalidChar}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { + for _, version := range []string{"", "latest", "1", "1.2", "bogus"} { + t.Run(version, func(t *testing.T) { t.Parallel() ctrl := gomock.NewController(t) - defer ctrl.Finish() - mockStore := NewMockScope(ctrl) processor, err := NewRequestProcessor(nil, 0) require.NoError(t, err) - order := &raftcmdpb.Order{ - Type: &raftcmdpb.Order_LedgerScoped{ - LedgerScoped: &raftcmdpb.LedgerScopedOrder{ - Ledger: "main", - Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{ - DeleteNumscript: &raftcmdpb.DeleteNumscriptOrder{ - Name: tt.input}, - }, - }, - }, - } - - result, err := processor.ProcessOrder(order, mockStore) - require.Error(t, err) - require.ErrorIs(t, err, tt.wantErr) + // Version is validated before any store interaction (after parse). + result, perr := processor.ProcessOrder(saveNumscriptOrder("main", "pay", validNumscriptContent, version), mockStore) require.Nil(t, result) + var e *domain.ErrNumscriptInvalidVersion + require.ErrorAs(t, perr, &e) }) } } + +// TestProcessSaveNumscript_DuplicateVersionRejected: an already-stored version +// is immutable. +func TestProcessSaveNumscript_DuplicateVersionRejected(t *testing.T) { + t.Parallel() + + const ledger = "main" + + ctrl := gomock.NewController(t) + mockStore := NewMockScope(ctrl) + processor, err := NewRequestProcessor(nil, 0) + require.NoError(t, err) + + expectGetLedger(mockStore, domain.LedgerKey{Name: ledger}, (&commonpb.LedgerInfo{Name: ledger}).AsReader(), nil) + mockStore.EXPECT().NumscriptVersionExists(ledger, "pay", "1.0.0").Return(true, nil) + + result, perr := processor.ProcessOrder(saveNumscriptOrder(ledger, "pay", validNumscriptContent, "1.0.0"), mockStore) + require.Nil(t, result) + var e *domain.ErrNumscriptVersionAlreadyExists + require.ErrorAs(t, perr, &e) +} + +// TestProcessSaveNumscript_KeepsGreatestPointer: saving a lower version after a +// greater one keeps the latest pointer at the greatest. +func TestProcessSaveNumscript_KeepsGreatestPointer(t *testing.T) { + t.Parallel() + + const ledger = "main" + + ctrl := gomock.NewController(t) + mockStore := NewMockScope(ctrl) + processor, err := NewRequestProcessor(nil, 0) + require.NoError(t, err) + + expectGetLedger(mockStore, domain.LedgerKey{Name: ledger}, (&commonpb.LedgerInfo{Name: ledger}).AsReader(), nil) + mockStore.EXPECT().NumscriptVersionExists(ledger, "pay", "1.0.0").Return(false, nil) + mockStore.EXPECT().GetNumscriptLatestVersion(ledger, "pay").Return("2.0.0", nil) + mockStore.EXPECT().PutNumscript(ledger, gomock.Any()) + mockStore.EXPECT().GetDate().Return((&commonpb.Timestamp{}).AsReader()) + // New version (1.0.0) is lower than the current greatest (2.0.0): the pointer + // is restored to 2.0.0. + mockStore.EXPECT().SetNumscriptLatestVersion(ledger, "pay", "2.0.0") + + result, perr := processor.ProcessOrder(saveNumscriptOrder(ledger, "pay", validNumscriptContent, "1.0.0"), mockStore) + require.Nil(t, perr) + require.NotNil(t, result.GetSavedNumscript()) +} diff --git a/internal/domain/processing/processor_transaction.go b/internal/domain/processing/processor_transaction.go index f84f853002..feec4ffef8 100644 --- a/internal/domain/processing/processor_transaction.go +++ b/internal/domain/processing/processor_transaction.go @@ -8,6 +8,7 @@ import ( "github.com/formancehq/ledger/v3/internal/domain" "github.com/formancehq/ledger/v3/internal/proto/commonpb" "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" + "github.com/formancehq/ledger/v3/internal/storage/dal" ) func processCreateTransaction(ledger string, order *raftcmdpb.CreateTransactionOrder, ctx *Context) (*commonpb.LedgerLogPayload, domain.Describable) { @@ -38,19 +39,45 @@ func processCreateTransaction(ledger string, order *raftcmdpb.CreateTransactionO } } - // Resolve script reference: load content from preloaded cache. + // Resolve script reference: load content from the preloaded cache. The + // audited order keeps its selector ("latest" or an exact semver); "latest" + // is resolved here, at apply time, to the greatest stored semver. var script *commonpb.Script if ref := order.GetNumscriptReference(); ref != nil { - info, err := s.ResolveNumscriptContent(ledger, ref.GetName(), ref.GetVersion()) + name := ref.GetName() + version := ref.GetVersion() + + if version == "" || version == "latest" { + greatest, gErr := s.GetNumscriptLatestVersion(ledger, name) + if gErr != nil { + return nil, &domain.ErrStorageOperation{Operation: fmt.Sprintf("resolving latest numscript %q", name), Cause: gErr} + } + + if greatest == "" { + return nil, &domain.ErrNumscriptNotFound{Name: name} + } + + // Admission preloaded the content for the version it observed as the + // greatest. If the greatest advanced since planning (a concurrent + // save committed first), that content key is not covered — reject as + // stale so the retry re-plans against the new greatest. + if s.CheckCoverage(dal.SubAttrNumscriptContent, domain.NumscriptEntryKey{LedgerName: ledger, Name: name, Version: greatest}) != nil { + return nil, domain.ErrStaleProposal + } + + version = greatest + } + + info, err := s.ResolveNumscriptContent(ledger, name, version) if err != nil { return nil, &domain.ErrStorageOperation{ - Operation: fmt.Sprintf("resolving numscript %q v%s", ref.GetName(), ref.GetVersion()), + Operation: fmt.Sprintf("resolving numscript %q v%s", name, version), Cause: err, } } if info == nil { - return nil, &domain.ErrNumscriptNotFound{Name: ref.GetName()} + return nil, &domain.ErrNumscriptNotFound{Name: name, Version: version} } script = &commonpb.Script{ diff --git a/internal/domain/processing/skip_safe_scope.go b/internal/domain/processing/skip_safe_scope.go index b0e76952b2..84093d0936 100644 --- a/internal/domain/processing/skip_safe_scope.go +++ b/internal/domain/processing/skip_safe_scope.go @@ -198,7 +198,7 @@ func (s *skipSafeScope) UpdateChapter(chapter *commonpb.Chapter) { } // ────────────────────────────────────────────────────────────────────────── -// Numscript library — reads pass through; Put/Delete are NOT buffered. +// Numscript library — reads pass through; Put/Set are NOT buffered. // ────────────────────────────────────────────────────────────────────────── func (s *skipSafeScope) GetNumscriptLatestVersion(ledgerName string, name string) (string, error) { @@ -213,8 +213,8 @@ func (s *skipSafeScope) PutNumscript(ledgerName string, info *commonpb.Numscript trapUnbuffered("PutNumscript", map[string]any{"ledger": ledgerName}) } -func (s *skipSafeScope) DeleteNumscriptLatest(ledgerName string, name string) { - trapUnbuffered("DeleteNumscriptLatest", map[string]any{"ledger": ledgerName, "name": name}) +func (s *skipSafeScope) SetNumscriptLatestVersion(ledgerName string, name, version string) { + trapUnbuffered("SetNumscriptLatestVersion", map[string]any{"ledger": ledgerName, "name": name, "version": version}) } func (s *skipSafeScope) ResolveNumscriptContent(ledgerName string, name, version string) (commonpb.NumscriptInfoReader, error) { diff --git a/internal/domain/processing/skip_safe_scope_test.go b/internal/domain/processing/skip_safe_scope_test.go index 75b830f986..ed39d56cf9 100644 --- a/internal/domain/processing/skip_safe_scope_test.go +++ b/internal/domain/processing/skip_safe_scope_test.go @@ -45,7 +45,7 @@ func TestSkipSafeScope_TrapsNonBufferedMutations(t *testing.T) { {"RemoveClosingChapter", func() { trap.RemoveClosingChapter(7) }}, {"UpdateChapter", func() { trap.UpdateChapter(&commonpb.Chapter{}) }}, {"PutNumscript", func() { trap.PutNumscript("L", &commonpb.NumscriptInfo{}) }}, - {"DeleteNumscriptLatest", func() { trap.DeleteNumscriptLatest("L", "n") }}, + {"SetNumscriptLatestVersion", func() { trap.SetNumscriptLatestVersion("L", "n", "1.0.0") }}, {"SaveQueryCheckpoint", func() { trap.SaveQueryCheckpoint(&raftcmdpb.QueryCheckpointState{}) }}, {"DeleteQueryCheckpoint", func() { trap.DeleteQueryCheckpoint(7) }}, } diff --git a/internal/domain/processing/store.go b/internal/domain/processing/store.go index 822c9977b2..0d4b35d1ca 100644 --- a/internal/domain/processing/store.go +++ b/internal/domain/processing/store.go @@ -101,7 +101,7 @@ type Scope interface { GetNumscriptLatestVersion(ledgerName string, name string) (string, error) NumscriptVersionExists(ledgerName string, name, version string) (bool, error) PutNumscript(ledgerName string, info *commonpb.NumscriptInfo) - DeleteNumscriptLatest(ledgerName string, name string) + SetNumscriptLatestVersion(ledgerName string, name, version string) ResolveNumscriptContent(ledgerName string, name, version string) (commonpb.NumscriptInfoReader, error) // Query checkpoint operations diff --git a/internal/domain/processing/store_generated_test.go b/internal/domain/processing/store_generated_test.go index 4b9cbd6c7f..8b8689a66e 100644 --- a/internal/domain/processing/store_generated_test.go +++ b/internal/domain/processing/store_generated_test.go @@ -286,42 +286,6 @@ func (c *MockScopeCheckCoverageCall) DoAndReturn(f func(byte, CoverageKey) error return c } -// DeleteNumscriptLatest mocks base method. -func (m *MockScope) DeleteNumscriptLatest(ledgerName, name string) { - m.ctrl.T.Helper() - m.ctrl.Call(m, "DeleteNumscriptLatest", ledgerName, name) -} - -// DeleteNumscriptLatest indicates an expected call of DeleteNumscriptLatest. -func (mr *MockScopeMockRecorder) DeleteNumscriptLatest(ledgerName, name any) *MockScopeDeleteNumscriptLatestCall { - mr.mock.ctrl.T.Helper() - call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteNumscriptLatest", reflect.TypeOf((*MockScope)(nil).DeleteNumscriptLatest), ledgerName, name) - return &MockScopeDeleteNumscriptLatestCall{Call: call} -} - -// MockScopeDeleteNumscriptLatestCall wrap *gomock.Call -type MockScopeDeleteNumscriptLatestCall struct { - *gomock.Call -} - -// Return rewrite *gomock.Call.Return -func (c *MockScopeDeleteNumscriptLatestCall) Return() *MockScopeDeleteNumscriptLatestCall { - c.Call = c.Call.Return() - return c -} - -// Do rewrite *gomock.Call.Do -func (c *MockScopeDeleteNumscriptLatestCall) Do(f func(string, string)) *MockScopeDeleteNumscriptLatestCall { - c.Call = c.Call.Do(f) - return c -} - -// DoAndReturn rewrite *gomock.Call.DoAndReturn -func (c *MockScopeDeleteNumscriptLatestCall) DoAndReturn(f func(string, string)) *MockScopeDeleteNumscriptLatestCall { - c.Call = c.Call.DoAndReturn(f) - return c -} - // DeleteQueryCheckpoint mocks base method. func (m *MockScope) DeleteQueryCheckpoint(checkpointID uint64) { m.ctrl.T.Helper() @@ -1530,6 +1494,42 @@ func (c *MockScopeSetMaintenanceModeCall) DoAndReturn(f func(bool)) *MockScopeSe return c } +// SetNumscriptLatestVersion mocks base method. +func (m *MockScope) SetNumscriptLatestVersion(ledgerName, name, version string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "SetNumscriptLatestVersion", ledgerName, name, version) +} + +// SetNumscriptLatestVersion indicates an expected call of SetNumscriptLatestVersion. +func (mr *MockScopeMockRecorder) SetNumscriptLatestVersion(ledgerName, name, version any) *MockScopeSetNumscriptLatestVersionCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNumscriptLatestVersion", reflect.TypeOf((*MockScope)(nil).SetNumscriptLatestVersion), ledgerName, name, version) + return &MockScopeSetNumscriptLatestVersionCall{Call: call} +} + +// MockScopeSetNumscriptLatestVersionCall wrap *gomock.Call +type MockScopeSetNumscriptLatestVersionCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockScopeSetNumscriptLatestVersionCall) Return() *MockScopeSetNumscriptLatestVersionCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockScopeSetNumscriptLatestVersionCall) Do(f func(string, string, string)) *MockScopeSetNumscriptLatestVersionCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockScopeSetNumscriptLatestVersionCall) DoAndReturn(f func(string, string, string)) *MockScopeSetNumscriptLatestVersionCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + // SetRequireSignatures mocks base method. func (m *MockScope) SetRequireSignatures(require bool) { m.ctrl.T.Helper() diff --git a/internal/infra/backup/rebuild.go b/internal/infra/backup/rebuild.go index d8ba20f1bf..6c6fc3d555 100644 --- a/internal/infra/backup/rebuild.go +++ b/internal/infra/backup/rebuild.go @@ -20,6 +20,7 @@ import ( "github.com/formancehq/ledger/v3/internal/infra/state" "github.com/formancehq/ledger/v3/internal/pkg/bitset" "github.com/formancehq/ledger/v3/internal/pkg/cursor" + "github.com/formancehq/ledger/v3/internal/pkg/semver" "github.com/formancehq/ledger/v3/internal/proto/auditpb" "github.com/formancehq/ledger/v3/internal/proto/commonpb" "github.com/formancehq/ledger/v3/internal/proto/raftcmdpb" @@ -61,6 +62,9 @@ func RebuildDelta( numscriptContent := attrs.NumscriptContent numscriptVersion := attrs.NumscriptVersion ledgerMetadata := attrs.LedgerMetadata + // Greatest semver seen per (ledger, name) — the write session is not + // readable, so track the latest pointer's target in memory during replay. + numscriptGreatest := make(map[string]string) rawLedgerTypes := make(map[string]map[string]*commonpb.AccountType) ledgerAccountTypes := make(map[string][]accounttype.CompiledType) @@ -333,9 +337,34 @@ func RebuildDelta( return fmt.Errorf("saving numscript at log %d: %w", seq, err) } + // The latest pointer is the greatest stored semver; versions may + // be saved out of order, so advance it only when the new version + // is greater. versionKey := domain.NumscriptVersionKey{LedgerName: nsLedger, Name: info.GetName()} - versionVal := &commonpb.NumscriptVersionValue{Version: info.GetVersion()} - if _, err := numscriptVersion.Set(batch, versionKey.Bytes(), versionVal); err != nil { + keyStr := string(versionKey.Bytes()) + // On an incremental rebuild the checkpoint store may already hold a + // greater pointer than this delta's saves; seed from it once per + // name so an out-of-order delta save cannot regress the pointer. + if _, ok := numscriptGreatest[keyStr]; !ok { + existing, err := numscriptVersion.Get(readHandle, versionKey.Bytes()) + if err != nil { + _ = batch.Cancel() + + return fmt.Errorf("reading existing numscript version at log %d: %w", seq, err) + } + + if existing != nil { + numscriptGreatest[keyStr] = existing.GetVersion() + } + } + + greatest := info.GetVersion() + if prev, ok := numscriptGreatest[keyStr]; ok && !numscriptVersionGreater(greatest, prev) { + greatest = prev + } + numscriptGreatest[keyStr] = greatest + + if _, err := numscriptVersion.Set(batch, versionKey.Bytes(), &commonpb.NumscriptVersionValue{Version: greatest}); err != nil { _ = batch.Cancel() return fmt.Errorf("saving numscript version at log %d: %w", seq, err) @@ -373,7 +402,6 @@ func RebuildDelta( case *commonpb.LogPayload_ConfirmArchiveChapter: case *commonpb.LogPayload_DeleteChapterSchedule: case *commonpb.LogPayload_DeletedPreparedQuery: - case *commonpb.LogPayload_DeletedNumscript: case *commonpb.LogPayload_CreatedQueryCheckpoint: case *commonpb.LogPayload_DeletedQueryCheckpoint: case *commonpb.LogPayload_DeleteQueryCheckpointSchedule: @@ -1200,3 +1228,19 @@ func (w *attributeReplayWriter) DeleteTxMetadata(canonicalKey []byte, key string return nil } + +// numscriptVersionGreater reports whether a is a strictly greater full semver +// than b. A non-semver b is treated as smaller so a valid version always wins. +func numscriptVersionGreater(a, b string) bool { + av, aerr := semver.Parse(a) + bv, berr := semver.Parse(b) + if aerr != nil { + return false + } + + if berr != nil { + return true + } + + return av.Compare(bv) > 0 +} diff --git a/internal/infra/state/audit_test.go b/internal/infra/state/audit_test.go index dca5563da5..2eb1b390f5 100644 --- a/internal/infra/state/audit_test.go +++ b/internal/infra/state/audit_test.go @@ -434,10 +434,6 @@ func TestExtractLedgers_WrapperCoversAllLedgerScopedPayloads(t *testing.T) { Ledger: "books", Payload: &raftcmdpb.LedgerScopedOrder_SaveNumscript{SaveNumscript: &raftcmdpb.SaveNumscriptOrder{}}, }, - "delete_numscript": { - Ledger: "books", - Payload: &raftcmdpb.LedgerScopedOrder_DeleteNumscript{DeleteNumscript: &raftcmdpb.DeleteNumscriptOrder{}}, - }, "create_prepared_query": { Ledger: "books", Payload: &raftcmdpb.LedgerScopedOrder_CreatePreparedQuery{CreatePreparedQuery: &raftcmdpb.CreatePreparedQueryOrder{}}, diff --git a/internal/infra/state/write_set.go b/internal/infra/state/write_set.go index 261d7d5b5e..640a58c5c7 100644 --- a/internal/infra/state/write_set.go +++ b/internal/infra/state/write_set.go @@ -1681,8 +1681,11 @@ func (b *WriteSet) PutNumscript(ledgerName string, info *commonpb.NumscriptInfo) b.Derived.NumscriptContents.Put(domain.NumscriptEntryKey{LedgerName: ledgerName, Name: info.GetName(), Version: info.GetVersion()}, info) } -func (b *WriteSet) DeleteNumscriptLatest(ledgerName string, name string) { - b.Derived.NumscriptVersions.Put(domain.NumscriptVersionKey{LedgerName: ledgerName, Name: name}, &commonpb.NumscriptVersionValue{}) +// SetNumscriptLatestVersion sets the per-name latest pointer. Used by save to +// keep the pointer at the greatest stored semver when versions are added out +// of order. +func (b *WriteSet) SetNumscriptLatestVersion(ledgerName string, name, version string) { + b.Derived.NumscriptVersions.Put(domain.NumscriptVersionKey{LedgerName: ledgerName, Name: name}, &commonpb.NumscriptVersionValue{Version: version}) } func (b *WriteSet) NumscriptVersionExists(ledgerName string, name, version string) (bool, error) { diff --git a/internal/pkg/semver/semver.go b/internal/pkg/semver/semver.go index eb36d69d4f..fe2adf7961 100644 --- a/internal/pkg/semver/semver.go +++ b/internal/pkg/semver/semver.go @@ -18,7 +18,36 @@ func (v Version) String() string { return fmt.Sprintf("%d.%d.%d", v.Major, v.Minor, v.Patch) } -// Parse parses a strict "major.minor.patch" version string. +// Compare returns -1 if v < o, +1 if v > o, and 0 if they are equal. +func (v Version) Compare(o Version) int { + switch { + case v.Major != o.Major: + if v.Major < o.Major { + return -1 + } + + return 1 + case v.Minor != o.Minor: + if v.Minor < o.Minor { + return -1 + } + + return 1 + case v.Patch != o.Patch: + if v.Patch < o.Patch { + return -1 + } + + return 1 + default: + return 0 + } +} + +// Parse parses a strict, canonical "major.minor.patch" version string. +// Non-canonical forms (leading zeros, e.g. "01.0.0") are rejected: callers use +// the raw string as a storage key while comparing the parsed value, so two +// strings that parse equal but differ textually would diverge the projection. func Parse(s string) (Version, error) { parts := strings.Split(s, ".") if len(parts) != 3 { @@ -47,6 +76,10 @@ func Parse(s string) (Version, error) { } } + if v.String() != s { + return Version{}, fmt.Errorf("invalid semver %q: non-canonical form, expected %q", s, v.String()) + } + return v, nil } diff --git a/internal/pkg/semver/semver_test.go b/internal/pkg/semver/semver_test.go index 4300262922..a9b3bc0244 100644 --- a/internal/pkg/semver/semver_test.go +++ b/internal/pkg/semver/semver_test.go @@ -23,6 +23,11 @@ func TestParse(t *testing.T) { {"1.0.0.0", Version{}, true}, {"a.b.c", Version{}, true}, {"1..0", Version{}, true}, + // Non-canonical (leading zeros) must be rejected: the raw string is a + // storage key, so "01.0.0" and "1.0.0" would diverge the projection. + {"01.0.0", Version{}, true}, + {"1.00.0", Version{}, true}, + {"1.0.007", Version{}, true}, } for _, tc := range tests { diff --git a/internal/proto/commonpb/common.pb.go b/internal/proto/commonpb/common.pb.go index a97bde0776..98a9aaa087 100644 --- a/internal/proto/commonpb/common.pb.go +++ b/internal/proto/commonpb/common.pb.go @@ -3122,7 +3122,6 @@ type LogPayload struct { // *LogPayload_UpdatedPreparedQuery // *LogPayload_DeletedPreparedQuery // *LogPayload_SavedNumscript - // *LogPayload_DeletedNumscript // *LogPayload_CreatedQueryCheckpoint // *LogPayload_DeletedQueryCheckpoint // *LogPayload_SetQueryCheckpointSchedule @@ -3351,15 +3350,6 @@ func (x *LogPayload) GetSavedNumscript() *SavedNumscriptLog { return nil } -func (x *LogPayload) GetDeletedNumscript() *DeletedNumscriptLog { - if x != nil { - if x, ok := x.Type.(*LogPayload_DeletedNumscript); ok { - return x.DeletedNumscript - } - } - return nil -} - func (x *LogPayload) GetCreatedQueryCheckpoint() *CreatedQueryCheckpointLog { if x != nil { if x, ok := x.Type.(*LogPayload_CreatedQueryCheckpoint); ok { @@ -3498,10 +3488,6 @@ type LogPayload_SavedNumscript struct { SavedNumscript *SavedNumscriptLog `protobuf:"bytes,21,opt,name=saved_numscript,json=savedNumscript,proto3,oneof"` } -type LogPayload_DeletedNumscript struct { - DeletedNumscript *DeletedNumscriptLog `protobuf:"bytes,22,opt,name=deleted_numscript,json=deletedNumscript,proto3,oneof"` -} - type LogPayload_CreatedQueryCheckpoint struct { CreatedQueryCheckpoint *CreatedQueryCheckpointLog `protobuf:"bytes,23,opt,name=created_query_checkpoint,json=createdQueryCheckpoint,proto3,oneof"` } @@ -3566,8 +3552,6 @@ func (*LogPayload_DeletedPreparedQuery) isLogPayload_Type() {} func (*LogPayload_SavedNumscript) isLogPayload_Type() {} -func (*LogPayload_DeletedNumscript) isLogPayload_Type() {} - func (*LogPayload_CreatedQueryCheckpoint) isLogPayload_Type() {} func (*LogPayload_DeletedQueryCheckpoint) isLogPayload_Type() {} @@ -4599,7 +4583,7 @@ func (x *DeletedLedgerMetadataLog) GetKey() string { return "" } -// NumscriptInfo represents a stored numscript with versioning. +// NumscriptInfo represents a stored, immutable numscript version. type NumscriptInfo struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -4676,7 +4660,7 @@ func (x *NumscriptInfo) GetLedger() string { return "" } -// SavedNumscriptLog records a numscript being saved to the library. +// SavedNumscriptLog records a numscript version being saved to the library. type SavedNumscriptLog struct { state protoimpl.MessageState `protogen:"open.v1"` Info *NumscriptInfo `protobuf:"bytes,1,opt,name=info,proto3" json:"info,omitempty"` @@ -4721,29 +4705,29 @@ func (x *SavedNumscriptLog) GetInfo() *NumscriptInfo { return nil } -// DeletedNumscriptLog records a numscript being deleted from the library. -type DeletedNumscriptLog struct { +// NumscriptVersionEntry describes one stored, immutable version of a numscript. +type NumscriptVersionEntry struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Ledger string `protobuf:"bytes,2,opt,name=ledger,proto3" json:"ledger,omitempty"` + Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` + CreatedAt *Timestamp `protobuf:"bytes,2,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeletedNumscriptLog) Reset() { - *x = DeletedNumscriptLog{} +func (x *NumscriptVersionEntry) Reset() { + *x = NumscriptVersionEntry{} mi := &file_common_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeletedNumscriptLog) String() string { +func (x *NumscriptVersionEntry) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeletedNumscriptLog) ProtoMessage() {} +func (*NumscriptVersionEntry) ProtoMessage() {} -func (x *DeletedNumscriptLog) ProtoReflect() protoreflect.Message { +func (x *NumscriptVersionEntry) ProtoReflect() protoreflect.Message { mi := &file_common_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -4755,23 +4739,23 @@ func (x *DeletedNumscriptLog) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeletedNumscriptLog.ProtoReflect.Descriptor instead. -func (*DeletedNumscriptLog) Descriptor() ([]byte, []int) { +// Deprecated: Use NumscriptVersionEntry.ProtoReflect.Descriptor instead. +func (*NumscriptVersionEntry) Descriptor() ([]byte, []int) { return file_common_proto_rawDescGZIP(), []int{48} } -func (x *DeletedNumscriptLog) GetName() string { +func (x *NumscriptVersionEntry) GetVersion() string { if x != nil { - return x.Name + return x.Version } return "" } -func (x *DeletedNumscriptLog) GetLedger() string { +func (x *NumscriptVersionEntry) GetCreatedAt() *Timestamp { if x != nil { - return x.Ledger + return x.CreatedAt } - return "" + return nil } // TemplateUsage tracks per-template invocation usage. Persisted as a @@ -13043,7 +13027,7 @@ const file_common_proto_rawDesc = "" + "\bsequence\x18\x01 \x01(\x06R\bsequence\x12,\n" + "\apayload\x18\x02 \x01(\v2\x12.common.LogPayloadR\apayload\x12\x18\n" + "\areceipt\x18\x06 \x01(\tR\areceipt\x12C\n" + - "\x12response_signature\x18\a \x01(\v2\x14.signature.SignedLogR\x11responseSignatureJ\x04\b\x04\x10\x05J\x04\b\b\x10\t\"\xab\x11\n" + + "\x12response_signature\x18\a \x01(\v2\x14.signature.SignedLogR\x11responseSignatureJ\x04\b\x04\x10\x05J\x04\b\b\x10\t\"\xdf\x10\n" + "\n" + "LogPayload\x12?\n" + "\rcreate_ledger\x18\x01 \x01(\v2\x18.common.CreatedLedgerLogH\x00R\fcreateLedger\x12?\n" + @@ -13066,8 +13050,7 @@ const file_common_proto_rawDesc = "" + "\x16created_prepared_query\x18\x12 \x01(\v2\x1f.common.CreatedPreparedQueryLogH\x00R\x14createdPreparedQuery\x12W\n" + "\x16updated_prepared_query\x18\x13 \x01(\v2\x1f.common.UpdatedPreparedQueryLogH\x00R\x14updatedPreparedQuery\x12W\n" + "\x16deleted_prepared_query\x18\x14 \x01(\v2\x1f.common.DeletedPreparedQueryLogH\x00R\x14deletedPreparedQuery\x12D\n" + - "\x0fsaved_numscript\x18\x15 \x01(\v2\x19.common.SavedNumscriptLogH\x00R\x0esavedNumscript\x12J\n" + - "\x11deleted_numscript\x18\x16 \x01(\v2\x1b.common.DeletedNumscriptLogH\x00R\x10deletedNumscript\x12]\n" + + "\x0fsaved_numscript\x18\x15 \x01(\v2\x19.common.SavedNumscriptLogH\x00R\x0esavedNumscript\x12]\n" + "\x18created_query_checkpoint\x18\x17 \x01(\v2!.common.CreatedQueryCheckpointLogH\x00R\x16createdQueryCheckpoint\x12]\n" + "\x18deleted_query_checkpoint\x18\x18 \x01(\v2!.common.DeletedQueryCheckpointLogH\x00R\x16deletedQueryCheckpoint\x12j\n" + "\x1dset_query_checkpoint_schedule\x18\x19 \x01(\v2%.common.SetQueryCheckpointScheduleLogH\x00R\x1asetQueryCheckpointSchedule\x12t\n" + @@ -13154,10 +13137,11 @@ const file_common_proto_rawDesc = "" + "created_at\x18\x04 \x01(\v2\x11.common.TimestampR\tcreatedAt\x12\x16\n" + "\x06ledger\x18\x05 \x01(\tR\x06ledger\">\n" + "\x11SavedNumscriptLog\x12)\n" + - "\x04info\x18\x01 \x01(\v2\x15.common.NumscriptInfoR\x04info\"A\n" + - "\x13DeletedNumscriptLog\x12\x12\n" + - "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" + - "\x06ledger\x18\x02 \x01(\tR\x06ledger\"U\n" + + "\x04info\x18\x01 \x01(\v2\x15.common.NumscriptInfoR\x04info\"c\n" + + "\x15NumscriptVersionEntry\x12\x18\n" + + "\aversion\x18\x01 \x01(\tR\aversion\x120\n" + + "\n" + + "created_at\x18\x02 \x01(\v2\x11.common.TimestampR\tcreatedAt\"U\n" + "\rTemplateUsage\x12\x14\n" + "\x05count\x18\x01 \x01(\x06R\x05count\x12.\n" + "\tlast_used\x18\x02 \x01(\v2\x11.common.TimestampR\blastUsed\"3\n" + @@ -13967,7 +13951,7 @@ var file_common_proto_goTypes = []any{ (*DeletedLedgerMetadataLog)(nil), // 63: common.DeletedLedgerMetadataLog (*NumscriptInfo)(nil), // 64: common.NumscriptInfo (*SavedNumscriptLog)(nil), // 65: common.SavedNumscriptLog - (*DeletedNumscriptLog)(nil), // 66: common.DeletedNumscriptLog + (*NumscriptVersionEntry)(nil), // 66: common.NumscriptVersionEntry (*TemplateUsage)(nil), // 67: common.TemplateUsage (*SetQueryCheckpointScheduleLog)(nil), // 68: common.SetQueryCheckpointScheduleLog (*DeletedQueryCheckpointScheduleLog)(nil), // 69: common.DeletedQueryCheckpointScheduleLog @@ -14159,34 +14143,34 @@ var file_common_proto_depIdxs = []int32{ 60, // 54: common.LogPayload.updated_prepared_query:type_name -> common.UpdatedPreparedQueryLog 61, // 55: common.LogPayload.deleted_prepared_query:type_name -> common.DeletedPreparedQueryLog 65, // 56: common.LogPayload.saved_numscript:type_name -> common.SavedNumscriptLog - 66, // 57: common.LogPayload.deleted_numscript:type_name -> common.DeletedNumscriptLog - 70, // 58: common.LogPayload.created_query_checkpoint:type_name -> common.CreatedQueryCheckpointLog - 71, // 59: common.LogPayload.deleted_query_checkpoint:type_name -> common.DeletedQueryCheckpointLog - 68, // 60: common.LogPayload.set_query_checkpoint_schedule:type_name -> common.SetQueryCheckpointScheduleLog - 69, // 61: common.LogPayload.delete_query_checkpoint_schedule:type_name -> common.DeletedQueryCheckpointScheduleLog - 62, // 62: common.LogPayload.saved_ledger_metadata:type_name -> common.SavedLedgerMetadataLog - 63, // 63: common.LogPayload.deleted_ledger_metadata:type_name -> common.DeletedLedgerMetadataLog - 72, // 64: common.AddedEventsSinkLog.config:type_name -> common.SinkConfig - 54, // 65: common.ClusterConfig.bloom_volumes:type_name -> common.BloomTypeConfig - 54, // 66: common.ClusterConfig.bloom_metadata:type_name -> common.BloomTypeConfig - 54, // 67: common.ClusterConfig.bloom_references:type_name -> common.BloomTypeConfig - 54, // 68: common.ClusterConfig.bloom_ledgers:type_name -> common.BloomTypeConfig - 54, // 69: common.ClusterConfig.bloom_boundaries:type_name -> common.BloomTypeConfig - 54, // 70: common.ClusterConfig.bloom_transactions:type_name -> common.BloomTypeConfig - 54, // 71: common.ClusterConfig.bloom_sink_configs:type_name -> common.BloomTypeConfig - 54, // 72: common.ClusterConfig.bloom_numscript_versions:type_name -> common.BloomTypeConfig - 54, // 73: common.ClusterConfig.bloom_numscript_contents:type_name -> common.BloomTypeConfig - 6, // 74: common.ClusterConfig.hash_algorithm:type_name -> common.HashAlgorithm - 54, // 75: common.ClusterConfig.bloom_ledger_metadata:type_name -> common.BloomTypeConfig - 54, // 76: common.ClusterConfig.bloom_prepared_queries:type_name -> common.BloomTypeConfig - 54, // 77: common.ClusterConfig.bloom_indexes:type_name -> common.BloomTypeConfig - 55, // 78: common.PersistedClusterState.config:type_name -> common.ClusterConfig - 164, // 79: common.CreatedPreparedQueryLog.query:type_name -> common.PreparedQuery - 144, // 80: common.UpdatedPreparedQueryLog.previous_filter:type_name -> common.QueryFilter - 144, // 81: common.UpdatedPreparedQueryLog.new_filter:type_name -> common.QueryFilter - 186, // 82: common.SavedLedgerMetadataLog.metadata:type_name -> common.SavedLedgerMetadataLog.MetadataEntry - 18, // 83: common.NumscriptInfo.created_at:type_name -> common.Timestamp - 64, // 84: common.SavedNumscriptLog.info:type_name -> common.NumscriptInfo + 70, // 57: common.LogPayload.created_query_checkpoint:type_name -> common.CreatedQueryCheckpointLog + 71, // 58: common.LogPayload.deleted_query_checkpoint:type_name -> common.DeletedQueryCheckpointLog + 68, // 59: common.LogPayload.set_query_checkpoint_schedule:type_name -> common.SetQueryCheckpointScheduleLog + 69, // 60: common.LogPayload.delete_query_checkpoint_schedule:type_name -> common.DeletedQueryCheckpointScheduleLog + 62, // 61: common.LogPayload.saved_ledger_metadata:type_name -> common.SavedLedgerMetadataLog + 63, // 62: common.LogPayload.deleted_ledger_metadata:type_name -> common.DeletedLedgerMetadataLog + 72, // 63: common.AddedEventsSinkLog.config:type_name -> common.SinkConfig + 54, // 64: common.ClusterConfig.bloom_volumes:type_name -> common.BloomTypeConfig + 54, // 65: common.ClusterConfig.bloom_metadata:type_name -> common.BloomTypeConfig + 54, // 66: common.ClusterConfig.bloom_references:type_name -> common.BloomTypeConfig + 54, // 67: common.ClusterConfig.bloom_ledgers:type_name -> common.BloomTypeConfig + 54, // 68: common.ClusterConfig.bloom_boundaries:type_name -> common.BloomTypeConfig + 54, // 69: common.ClusterConfig.bloom_transactions:type_name -> common.BloomTypeConfig + 54, // 70: common.ClusterConfig.bloom_sink_configs:type_name -> common.BloomTypeConfig + 54, // 71: common.ClusterConfig.bloom_numscript_versions:type_name -> common.BloomTypeConfig + 54, // 72: common.ClusterConfig.bloom_numscript_contents:type_name -> common.BloomTypeConfig + 6, // 73: common.ClusterConfig.hash_algorithm:type_name -> common.HashAlgorithm + 54, // 74: common.ClusterConfig.bloom_ledger_metadata:type_name -> common.BloomTypeConfig + 54, // 75: common.ClusterConfig.bloom_prepared_queries:type_name -> common.BloomTypeConfig + 54, // 76: common.ClusterConfig.bloom_indexes:type_name -> common.BloomTypeConfig + 55, // 77: common.PersistedClusterState.config:type_name -> common.ClusterConfig + 164, // 78: common.CreatedPreparedQueryLog.query:type_name -> common.PreparedQuery + 144, // 79: common.UpdatedPreparedQueryLog.previous_filter:type_name -> common.QueryFilter + 144, // 80: common.UpdatedPreparedQueryLog.new_filter:type_name -> common.QueryFilter + 186, // 81: common.SavedLedgerMetadataLog.metadata:type_name -> common.SavedLedgerMetadataLog.MetadataEntry + 18, // 82: common.NumscriptInfo.created_at:type_name -> common.Timestamp + 64, // 83: common.SavedNumscriptLog.info:type_name -> common.NumscriptInfo + 18, // 84: common.NumscriptVersionEntry.created_at:type_name -> common.Timestamp 18, // 85: common.TemplateUsage.last_used:type_name -> common.Timestamp 75, // 86: common.SinkConfig.nats:type_name -> common.NatsSinkConfig 76, // 87: common.SinkConfig.clickhouse:type_name -> common.ClickHouseSinkConfig @@ -14435,7 +14419,6 @@ func file_common_proto_init() { (*LogPayload_UpdatedPreparedQuery)(nil), (*LogPayload_DeletedPreparedQuery)(nil), (*LogPayload_SavedNumscript)(nil), - (*LogPayload_DeletedNumscript)(nil), (*LogPayload_CreatedQueryCheckpoint)(nil), (*LogPayload_DeletedQueryCheckpoint)(nil), (*LogPayload_SetQueryCheckpointSchedule)(nil), diff --git a/internal/proto/commonpb/common_dethash.pb.go b/internal/proto/commonpb/common_dethash.pb.go index 25dbe2c75e..2b90b93fac 100644 --- a/internal/proto/commonpb/common_dethash.pb.go +++ b/internal/proto/commonpb/common_dethash.pb.go @@ -960,16 +960,6 @@ func (m *LogPayload) MarshalToSizedBufferDeterministicVT(dAtA []byte) (int, erro i-- dAtA[i] = 0xaa } - case *LogPayload_DeletedNumscript: - if v.DeletedNumscript != nil { - size, _ := v.DeletedNumscript.MarshalToSizedBufferVT(dAtA[:i]) - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb2 - } case *LogPayload_CreatedQueryCheckpoint: if v.CreatedQueryCheckpoint != nil { size, _ := v.CreatedQueryCheckpoint.MarshalToSizedBufferVT(dAtA[:i]) @@ -1300,7 +1290,7 @@ func (m *SavedNumscriptLog) MarshalDeterministicVT(dAtA []byte) []byte { return append(dAtA, b...) } -func (m *DeletedNumscriptLog) MarshalDeterministicVT(dAtA []byte) []byte { +func (m *NumscriptVersionEntry) MarshalDeterministicVT(dAtA []byte) []byte { if m == nil { return dAtA } diff --git a/internal/proto/commonpb/common_reader.pb.go b/internal/proto/commonpb/common_reader.pb.go index d7b3e245bb..c1d68a8432 100644 --- a/internal/proto/commonpb/common_reader.pb.go +++ b/internal/proto/commonpb/common_reader.pb.go @@ -3998,53 +3998,57 @@ func NewSavedNumscriptLogListReader(s []*SavedNumscriptLog) SavedNumscriptLogLis return savedNumscriptLogListReadonly(s) } -// DeletedNumscriptLogReader provides read-only access to DeletedNumscriptLog. +// NumscriptVersionEntryReader provides read-only access to NumscriptVersionEntry. // Call Mutate() to obtain a mutable clone. -type DeletedNumscriptLogReader interface { - GetName() string - GetLedger() string - Mutate() *DeletedNumscriptLog +type NumscriptVersionEntryReader interface { + GetVersion() string + GetCreatedAt() TimestampReader + Mutate() *NumscriptVersionEntry } -type deletedNumscriptLogReadonly DeletedNumscriptLog +type numscriptVersionEntryReadonly NumscriptVersionEntry -func (r *deletedNumscriptLogReadonly) GetName() string { - return (*DeletedNumscriptLog)(r).GetName() +func (r *numscriptVersionEntryReadonly) GetVersion() string { + return (*NumscriptVersionEntry)(r).GetVersion() } -func (r *deletedNumscriptLogReadonly) GetLedger() string { - return (*DeletedNumscriptLog)(r).GetLedger() +func (r *numscriptVersionEntryReadonly) GetCreatedAt() TimestampReader { + v := (*NumscriptVersionEntry)(r).GetCreatedAt() + if v == nil { + return nil + } + return v.AsReader() } -func (r *deletedNumscriptLogReadonly) Mutate() *DeletedNumscriptLog { - return (*DeletedNumscriptLog)(r).CloneVT() +func (r *numscriptVersionEntryReadonly) Mutate() *NumscriptVersionEntry { + return (*NumscriptVersionEntry)(r).CloneVT() } -// AsReader returns a read-only view of this DeletedNumscriptLog. -func (m *DeletedNumscriptLog) AsReader() DeletedNumscriptLogReader { +// AsReader returns a read-only view of this NumscriptVersionEntry. +func (m *NumscriptVersionEntry) AsReader() NumscriptVersionEntryReader { if m == nil { return nil } - return (*deletedNumscriptLogReadonly)(m) + return (*numscriptVersionEntryReadonly)(m) } -// Mutate returns a mutable deep clone of this DeletedNumscriptLog. -func (m *DeletedNumscriptLog) Mutate() *DeletedNumscriptLog { +// Mutate returns a mutable deep clone of this NumscriptVersionEntry. +func (m *NumscriptVersionEntry) Mutate() *NumscriptVersionEntry { return m.CloneVT() } -// DeletedNumscriptLogListReader provides read-only iteration over []*DeletedNumscriptLog. -type DeletedNumscriptLogListReader interface { +// NumscriptVersionEntryListReader provides read-only iteration over []*NumscriptVersionEntry. +type NumscriptVersionEntryListReader interface { Len() int - Get(i int) DeletedNumscriptLogReader - Range(yield func(int, DeletedNumscriptLogReader) bool) + Get(i int) NumscriptVersionEntryReader + Range(yield func(int, NumscriptVersionEntryReader) bool) } -type deletedNumscriptLogListReadonly []*DeletedNumscriptLog +type numscriptVersionEntryListReadonly []*NumscriptVersionEntry -func (l deletedNumscriptLogListReadonly) Len() int { return len(l) } +func (l numscriptVersionEntryListReadonly) Len() int { return len(l) } -func (l deletedNumscriptLogListReadonly) Get(i int) DeletedNumscriptLogReader { +func (l numscriptVersionEntryListReadonly) Get(i int) NumscriptVersionEntryReader { v := l[i] if v == nil { return nil @@ -4052,9 +4056,9 @@ func (l deletedNumscriptLogListReadonly) Get(i int) DeletedNumscriptLogReader { return v.AsReader() } -func (l deletedNumscriptLogListReadonly) Range(yield func(int, DeletedNumscriptLogReader) bool) { +func (l numscriptVersionEntryListReadonly) Range(yield func(int, NumscriptVersionEntryReader) bool) { for i, v := range l { - var r DeletedNumscriptLogReader + var r NumscriptVersionEntryReader if v != nil { r = v.AsReader() } @@ -4064,10 +4068,10 @@ func (l deletedNumscriptLogListReadonly) Range(yield func(int, DeletedNumscriptL } } -// NewDeletedNumscriptLogListReader wraps s for read-only iteration. The returned +// NewNumscriptVersionEntryListReader wraps s for read-only iteration. The returned // view aliases the underlying slice; do not mutate s afterwards. -func NewDeletedNumscriptLogListReader(s []*DeletedNumscriptLog) DeletedNumscriptLogListReader { - return deletedNumscriptLogListReadonly(s) +func NewNumscriptVersionEntryListReader(s []*NumscriptVersionEntry) NumscriptVersionEntryListReader { + return numscriptVersionEntryListReadonly(s) } // TemplateUsageReader provides read-only access to TemplateUsage. diff --git a/internal/proto/commonpb/common_vtproto.pb.go b/internal/proto/commonpb/common_vtproto.pb.go index 1b0379797b..5233734c56 100644 --- a/internal/proto/commonpb/common_vtproto.pb.go +++ b/internal/proto/commonpb/common_vtproto.pb.go @@ -952,15 +952,6 @@ func (m *LogPayload_SavedNumscript) CloneVT() isLogPayload_Type { return r } -func (m *LogPayload_DeletedNumscript) CloneVT() isLogPayload_Type { - if m == nil { - return (*LogPayload_DeletedNumscript)(nil) - } - r := new(LogPayload_DeletedNumscript) - r.DeletedNumscript = m.DeletedNumscript.CloneVT() - return r -} - func (m *LogPayload_CreatedQueryCheckpoint) CloneVT() isLogPayload_Type { if m == nil { return (*LogPayload_CreatedQueryCheckpoint)(nil) @@ -1403,13 +1394,13 @@ func (m *SavedNumscriptLog) CloneMessageVT() proto.Message { return m.CloneVT() } -func (m *DeletedNumscriptLog) CloneVT() *DeletedNumscriptLog { +func (m *NumscriptVersionEntry) CloneVT() *NumscriptVersionEntry { if m == nil { - return (*DeletedNumscriptLog)(nil) + return (*NumscriptVersionEntry)(nil) } - r := new(DeletedNumscriptLog) - r.Name = m.Name - r.Ledger = m.Ledger + r := new(NumscriptVersionEntry) + r.Version = m.Version + r.CreatedAt = m.CreatedAt.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) @@ -1417,7 +1408,7 @@ func (m *DeletedNumscriptLog) CloneVT() *DeletedNumscriptLog { return r } -func (m *DeletedNumscriptLog) CloneMessageVT() proto.Message { +func (m *NumscriptVersionEntry) CloneMessageVT() proto.Message { return m.CloneVT() } @@ -6232,31 +6223,6 @@ func (this *LogPayload_SavedNumscript) EqualVT(thatIface isLogPayload_Type) bool return true } -func (this *LogPayload_DeletedNumscript) EqualVT(thatIface isLogPayload_Type) bool { - that, ok := thatIface.(*LogPayload_DeletedNumscript) - if !ok { - return false - } - if this == that { - return true - } - if this == nil && that != nil || this != nil && that == nil { - return false - } - if p, q := this.DeletedNumscript, that.DeletedNumscript; p != q { - if p == nil { - p = &DeletedNumscriptLog{} - } - if q == nil { - q = &DeletedNumscriptLog{} - } - if !p.EqualVT(q) { - return false - } - } - return true -} - func (this *LogPayload_CreatedQueryCheckpoint) EqualVT(thatIface isLogPayload_Type) bool { that, ok := thatIface.(*LogPayload_CreatedQueryCheckpoint) if !ok { @@ -6900,23 +6866,23 @@ func (this *SavedNumscriptLog) EqualMessageVT(thatMsg proto.Message) bool { } return this.EqualVT(that) } -func (this *DeletedNumscriptLog) EqualVT(that *DeletedNumscriptLog) bool { +func (this *NumscriptVersionEntry) EqualVT(that *NumscriptVersionEntry) bool { if this == that { return true } else if this == nil || that == nil { return false } - if this.Name != that.Name { + if this.Version != that.Version { return false } - if this.Ledger != that.Ledger { + if !this.CreatedAt.EqualVT(that.CreatedAt) { return false } return string(this.unknownFields) == string(that.unknownFields) } -func (this *DeletedNumscriptLog) EqualMessageVT(thatMsg proto.Message) bool { - that, ok := thatMsg.(*DeletedNumscriptLog) +func (this *NumscriptVersionEntry) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*NumscriptVersionEntry) if !ok { return false } @@ -14445,27 +14411,6 @@ func (m *LogPayload_SavedNumscript) MarshalToSizedBufferVT(dAtA []byte) (int, er } return len(dAtA) - i, nil } -func (m *LogPayload_DeletedNumscript) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *LogPayload_DeletedNumscript) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DeletedNumscript != nil { - size, err := m.DeletedNumscript.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xb2 - } - return len(dAtA) - i, nil -} func (m *LogPayload_CreatedQueryCheckpoint) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) @@ -15674,7 +15619,7 @@ func (m *SavedNumscriptLog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DeletedNumscriptLog) MarshalVT() (dAtA []byte, err error) { +func (m *NumscriptVersionEntry) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -15687,12 +15632,12 @@ func (m *DeletedNumscriptLog) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DeletedNumscriptLog) MarshalToVT(dAtA []byte) (int, error) { +func (m *NumscriptVersionEntry) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *DeletedNumscriptLog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *NumscriptVersionEntry) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -15704,17 +15649,20 @@ func (m *DeletedNumscriptLog) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if len(m.Ledger) > 0 { - i -= len(m.Ledger) - copy(dAtA[i:], m.Ledger) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ledger))) + if m.CreatedAt != nil { + size, err := m.CreatedAt.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- dAtA[i] = 0x12 } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) i-- dAtA[i] = 0xa } @@ -24352,18 +24300,6 @@ func (m *LogPayload_SavedNumscript) SizeVT() (n int) { } return n } -func (m *LogPayload_DeletedNumscript) SizeVT() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DeletedNumscript != nil { - l = m.DeletedNumscript.SizeVT() - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) - } - return n -} func (m *LogPayload_CreatedQueryCheckpoint) SizeVT() (n int) { if m == nil { return 0 @@ -24840,18 +24776,18 @@ func (m *SavedNumscriptLog) SizeVT() (n int) { return n } -func (m *DeletedNumscriptLog) SizeVT() (n int) { +func (m *NumscriptVersionEntry) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Name) + l = len(m.Version) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.Ledger) - if l > 0 { + if m.CreatedAt != nil { + l = m.CreatedAt.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } n += len(m.unknownFields) @@ -33502,47 +33438,6 @@ func (m *LogPayload) UnmarshalVT(dAtA []byte) error { m.Type = &LogPayload_SavedNumscript{SavedNumscript: v} } iNdEx = postIndex - case 22: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeletedNumscript", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if oneof, ok := m.Type.(*LogPayload_DeletedNumscript); ok { - if err := oneof.DeletedNumscript.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - v := &DeletedNumscriptLog{} - if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Type = &LogPayload_DeletedNumscript{DeletedNumscript: v} - } - iNdEx = postIndex case 23: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedQueryCheckpoint", wireType) @@ -36502,7 +36397,7 @@ func (m *SavedNumscriptLog) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *DeletedNumscriptLog) UnmarshalVT(dAtA []byte) error { +func (m *NumscriptVersionEntry) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -36525,15 +36420,15 @@ func (m *DeletedNumscriptLog) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DeletedNumscriptLog: wiretype end group for non-group") + return fmt.Errorf("proto: NumscriptVersionEntry: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DeletedNumscriptLog: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: NumscriptVersionEntry: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -36561,13 +36456,13 @@ func (m *DeletedNumscriptLog) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return protohelpers.ErrIntOverflow @@ -36577,23 +36472,27 @@ func (m *DeletedNumscriptLog) UnmarshalVT(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return protohelpers.ErrInvalidLength } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return protohelpers.ErrInvalidLength } if postIndex > l { return io.ErrUnexpectedEOF } - m.Ledger = string(dAtA[iNdEx:postIndex]) + if m.CreatedAt == nil { + m.CreatedAt = &Timestamp{} + } + if err := m.CreatedAt.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex diff --git a/internal/proto/raftcmdpb/raft_cmd.pb.go b/internal/proto/raftcmdpb/raft_cmd.pb.go index 98f8c8ec00..904c9ba8ff 100644 --- a/internal/proto/raftcmdpb/raft_cmd.pb.go +++ b/internal/proto/raftcmdpb/raft_cmd.pb.go @@ -342,7 +342,6 @@ type LedgerScopedOrder struct { // *LedgerScopedOrder_SaveLedgerMetadata // *LedgerScopedOrder_DeleteLedgerMetadata // *LedgerScopedOrder_SaveNumscript - // *LedgerScopedOrder_DeleteNumscript // *LedgerScopedOrder_CreatePreparedQuery // *LedgerScopedOrder_UpdatePreparedQuery // *LedgerScopedOrder_DeletePreparedQuery @@ -467,15 +466,6 @@ func (x *LedgerScopedOrder) GetSaveNumscript() *SaveNumscriptOrder { return nil } -func (x *LedgerScopedOrder) GetDeleteNumscript() *DeleteNumscriptOrder { - if x != nil { - if x, ok := x.Payload.(*LedgerScopedOrder_DeleteNumscript); ok { - return x.DeleteNumscript - } - } - return nil -} - func (x *LedgerScopedOrder) GetCreatePreparedQuery() *CreatePreparedQueryOrder { if x != nil { if x, ok := x.Payload.(*LedgerScopedOrder_CreatePreparedQuery); ok { @@ -539,10 +529,6 @@ type LedgerScopedOrder_SaveNumscript struct { SaveNumscript *SaveNumscriptOrder `protobuf:"bytes,9,opt,name=save_numscript,json=saveNumscript,proto3,oneof"` } -type LedgerScopedOrder_DeleteNumscript struct { - DeleteNumscript *DeleteNumscriptOrder `protobuf:"bytes,10,opt,name=delete_numscript,json=deleteNumscript,proto3,oneof"` -} - type LedgerScopedOrder_CreatePreparedQuery struct { CreatePreparedQuery *CreatePreparedQueryOrder `protobuf:"bytes,11,opt,name=create_prepared_query,json=createPreparedQuery,proto3,oneof"` } @@ -571,8 +557,6 @@ func (*LedgerScopedOrder_DeleteLedgerMetadata) isLedgerScopedOrder_Payload() {} func (*LedgerScopedOrder_SaveNumscript) isLedgerScopedOrder_Payload() {} -func (*LedgerScopedOrder_DeleteNumscript) isLedgerScopedOrder_Payload() {} - func (*LedgerScopedOrder_CreatePreparedQuery) isLedgerScopedOrder_Payload() {} func (*LedgerScopedOrder_UpdatePreparedQuery) isLedgerScopedOrder_Payload() {} @@ -1581,6 +1565,8 @@ func (*DeleteChapterScheduleOrder) Descriptor() ([]byte, []int) { return file_raft_cmd_proto_rawDescGZIP(), []int{18} } +// SaveNumscriptOrder appends an immutable version to the library. version must +// be an explicit full semver. type SaveNumscriptOrder struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -1641,50 +1627,6 @@ func (x *SaveNumscriptOrder) GetVersion() string { return "" } -type DeleteNumscriptOrder struct { - state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *DeleteNumscriptOrder) Reset() { - *x = DeleteNumscriptOrder{} - mi := &file_raft_cmd_proto_msgTypes[20] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *DeleteNumscriptOrder) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*DeleteNumscriptOrder) ProtoMessage() {} - -func (x *DeleteNumscriptOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[20] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use DeleteNumscriptOrder.ProtoReflect.Descriptor instead. -func (*DeleteNumscriptOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{20} -} - -func (x *DeleteNumscriptOrder) GetName() string { - if x != nil { - return x.Name - } - return "" -} - // CreateQueryCheckpointOrder triggers a physical Pebble checkpoint via Raft. // The FSM commits the current batch and the Applier creates snapshots of both // the main store and read index, enabling point-in-time queries. @@ -1697,7 +1639,7 @@ type CreateQueryCheckpointOrder struct { func (x *CreateQueryCheckpointOrder) Reset() { *x = CreateQueryCheckpointOrder{} - mi := &file_raft_cmd_proto_msgTypes[21] + mi := &file_raft_cmd_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1709,7 +1651,7 @@ func (x *CreateQueryCheckpointOrder) String() string { func (*CreateQueryCheckpointOrder) ProtoMessage() {} func (x *CreateQueryCheckpointOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[21] + mi := &file_raft_cmd_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1722,7 +1664,7 @@ func (x *CreateQueryCheckpointOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateQueryCheckpointOrder.ProtoReflect.Descriptor instead. func (*CreateQueryCheckpointOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{21} + return file_raft_cmd_proto_rawDescGZIP(), []int{20} } // DeleteQueryCheckpointOrder removes a previously created query checkpoint. @@ -1736,7 +1678,7 @@ type DeleteQueryCheckpointOrder struct { func (x *DeleteQueryCheckpointOrder) Reset() { *x = DeleteQueryCheckpointOrder{} - mi := &file_raft_cmd_proto_msgTypes[22] + mi := &file_raft_cmd_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1748,7 +1690,7 @@ func (x *DeleteQueryCheckpointOrder) String() string { func (*DeleteQueryCheckpointOrder) ProtoMessage() {} func (x *DeleteQueryCheckpointOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[22] + mi := &file_raft_cmd_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1761,7 +1703,7 @@ func (x *DeleteQueryCheckpointOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteQueryCheckpointOrder.ProtoReflect.Descriptor instead. func (*DeleteQueryCheckpointOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{22} + return file_raft_cmd_proto_rawDescGZIP(), []int{21} } func (x *DeleteQueryCheckpointOrder) GetCheckpointId() uint64 { @@ -1784,7 +1726,7 @@ type QueryCheckpointState struct { func (x *QueryCheckpointState) Reset() { *x = QueryCheckpointState{} - mi := &file_raft_cmd_proto_msgTypes[23] + mi := &file_raft_cmd_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1796,7 +1738,7 @@ func (x *QueryCheckpointState) String() string { func (*QueryCheckpointState) ProtoMessage() {} func (x *QueryCheckpointState) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[23] + mi := &file_raft_cmd_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1809,7 +1751,7 @@ func (x *QueryCheckpointState) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryCheckpointState.ProtoReflect.Descriptor instead. func (*QueryCheckpointState) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{23} + return file_raft_cmd_proto_rawDescGZIP(), []int{22} } func (x *QueryCheckpointState) GetCheckpointId() uint64 { @@ -1842,7 +1784,7 @@ type SetQueryCheckpointScheduleOrder struct { func (x *SetQueryCheckpointScheduleOrder) Reset() { *x = SetQueryCheckpointScheduleOrder{} - mi := &file_raft_cmd_proto_msgTypes[24] + mi := &file_raft_cmd_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1854,7 +1796,7 @@ func (x *SetQueryCheckpointScheduleOrder) String() string { func (*SetQueryCheckpointScheduleOrder) ProtoMessage() {} func (x *SetQueryCheckpointScheduleOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[24] + mi := &file_raft_cmd_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1867,7 +1809,7 @@ func (x *SetQueryCheckpointScheduleOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use SetQueryCheckpointScheduleOrder.ProtoReflect.Descriptor instead. func (*SetQueryCheckpointScheduleOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{24} + return file_raft_cmd_proto_rawDescGZIP(), []int{23} } func (x *SetQueryCheckpointScheduleOrder) GetCron() string { @@ -1885,7 +1827,7 @@ type DeleteQueryCheckpointScheduleOrder struct { func (x *DeleteQueryCheckpointScheduleOrder) Reset() { *x = DeleteQueryCheckpointScheduleOrder{} - mi := &file_raft_cmd_proto_msgTypes[25] + mi := &file_raft_cmd_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1897,7 +1839,7 @@ func (x *DeleteQueryCheckpointScheduleOrder) String() string { func (*DeleteQueryCheckpointScheduleOrder) ProtoMessage() {} func (x *DeleteQueryCheckpointScheduleOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[25] + mi := &file_raft_cmd_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1910,7 +1852,7 @@ func (x *DeleteQueryCheckpointScheduleOrder) ProtoReflect() protoreflect.Message // Deprecated: Use DeleteQueryCheckpointScheduleOrder.ProtoReflect.Descriptor instead. func (*DeleteQueryCheckpointScheduleOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{25} + return file_raft_cmd_proto_rawDescGZIP(), []int{24} } type CreateLedgerOrder struct { @@ -1926,7 +1868,7 @@ type CreateLedgerOrder struct { func (x *CreateLedgerOrder) Reset() { *x = CreateLedgerOrder{} - mi := &file_raft_cmd_proto_msgTypes[26] + mi := &file_raft_cmd_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1938,7 +1880,7 @@ func (x *CreateLedgerOrder) String() string { func (*CreateLedgerOrder) ProtoMessage() {} func (x *CreateLedgerOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[26] + mi := &file_raft_cmd_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1951,7 +1893,7 @@ func (x *CreateLedgerOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateLedgerOrder.ProtoReflect.Descriptor instead. func (*CreateLedgerOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{26} + return file_raft_cmd_proto_rawDescGZIP(), []int{25} } func (x *CreateLedgerOrder) GetInitialSchema() []*commonpb.SetMetadataFieldTypeCommand { @@ -1998,7 +1940,7 @@ type MirrorIngestOrder struct { func (x *MirrorIngestOrder) Reset() { *x = MirrorIngestOrder{} - mi := &file_raft_cmd_proto_msgTypes[27] + mi := &file_raft_cmd_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2010,7 +1952,7 @@ func (x *MirrorIngestOrder) String() string { func (*MirrorIngestOrder) ProtoMessage() {} func (x *MirrorIngestOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[27] + mi := &file_raft_cmd_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2023,7 +1965,7 @@ func (x *MirrorIngestOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorIngestOrder.ProtoReflect.Descriptor instead. func (*MirrorIngestOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{27} + return file_raft_cmd_proto_rawDescGZIP(), []int{26} } func (x *MirrorIngestOrder) GetEntry() *MirrorLogEntry { @@ -2050,7 +1992,7 @@ type MirrorLogEntry struct { func (x *MirrorLogEntry) Reset() { *x = MirrorLogEntry{} - mi := &file_raft_cmd_proto_msgTypes[28] + mi := &file_raft_cmd_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2062,7 +2004,7 @@ func (x *MirrorLogEntry) String() string { func (*MirrorLogEntry) ProtoMessage() {} func (x *MirrorLogEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[28] + mi := &file_raft_cmd_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2075,7 +2017,7 @@ func (x *MirrorLogEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorLogEntry.ProtoReflect.Descriptor instead. func (*MirrorLogEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{28} + return file_raft_cmd_proto_rawDescGZIP(), []int{27} } func (x *MirrorLogEntry) GetV2LogId() uint64 { @@ -2180,7 +2122,7 @@ type MirrorFillGap struct { func (x *MirrorFillGap) Reset() { *x = MirrorFillGap{} - mi := &file_raft_cmd_proto_msgTypes[29] + mi := &file_raft_cmd_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2192,7 +2134,7 @@ func (x *MirrorFillGap) String() string { func (*MirrorFillGap) ProtoMessage() {} func (x *MirrorFillGap) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[29] + mi := &file_raft_cmd_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2205,7 +2147,7 @@ func (x *MirrorFillGap) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorFillGap.ProtoReflect.Descriptor instead. func (*MirrorFillGap) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{29} + return file_raft_cmd_proto_rawDescGZIP(), []int{28} } func (x *MirrorFillGap) GetSkippedTransactionIds() []uint64 { @@ -2229,7 +2171,7 @@ type MirrorCreatedTransaction struct { func (x *MirrorCreatedTransaction) Reset() { *x = MirrorCreatedTransaction{} - mi := &file_raft_cmd_proto_msgTypes[30] + mi := &file_raft_cmd_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2241,7 +2183,7 @@ func (x *MirrorCreatedTransaction) String() string { func (*MirrorCreatedTransaction) ProtoMessage() {} func (x *MirrorCreatedTransaction) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[30] + mi := &file_raft_cmd_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2254,7 +2196,7 @@ func (x *MirrorCreatedTransaction) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorCreatedTransaction.ProtoReflect.Descriptor instead. func (*MirrorCreatedTransaction) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{30} + return file_raft_cmd_proto_rawDescGZIP(), []int{29} } func (x *MirrorCreatedTransaction) GetTransactionId() uint64 { @@ -2309,7 +2251,7 @@ type MirrorSavedMetadata struct { func (x *MirrorSavedMetadata) Reset() { *x = MirrorSavedMetadata{} - mi := &file_raft_cmd_proto_msgTypes[31] + mi := &file_raft_cmd_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2321,7 +2263,7 @@ func (x *MirrorSavedMetadata) String() string { func (*MirrorSavedMetadata) ProtoMessage() {} func (x *MirrorSavedMetadata) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[31] + mi := &file_raft_cmd_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2334,7 +2276,7 @@ func (x *MirrorSavedMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorSavedMetadata.ProtoReflect.Descriptor instead. func (*MirrorSavedMetadata) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{31} + return file_raft_cmd_proto_rawDescGZIP(), []int{30} } func (x *MirrorSavedMetadata) GetTarget() *commonpb.Target { @@ -2364,7 +2306,7 @@ type MirrorRevertedTransaction struct { func (x *MirrorRevertedTransaction) Reset() { *x = MirrorRevertedTransaction{} - mi := &file_raft_cmd_proto_msgTypes[32] + mi := &file_raft_cmd_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2376,7 +2318,7 @@ func (x *MirrorRevertedTransaction) String() string { func (*MirrorRevertedTransaction) ProtoMessage() {} func (x *MirrorRevertedTransaction) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[32] + mi := &file_raft_cmd_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2389,7 +2331,7 @@ func (x *MirrorRevertedTransaction) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorRevertedTransaction.ProtoReflect.Descriptor instead. func (*MirrorRevertedTransaction) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{32} + return file_raft_cmd_proto_rawDescGZIP(), []int{31} } func (x *MirrorRevertedTransaction) GetRevertedTransactionId() uint64 { @@ -2437,7 +2379,7 @@ type MirrorDeletedMetadata struct { func (x *MirrorDeletedMetadata) Reset() { *x = MirrorDeletedMetadata{} - mi := &file_raft_cmd_proto_msgTypes[33] + mi := &file_raft_cmd_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2449,7 +2391,7 @@ func (x *MirrorDeletedMetadata) String() string { func (*MirrorDeletedMetadata) ProtoMessage() {} func (x *MirrorDeletedMetadata) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[33] + mi := &file_raft_cmd_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2462,7 +2404,7 @@ func (x *MirrorDeletedMetadata) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorDeletedMetadata.ProtoReflect.Descriptor instead. func (*MirrorDeletedMetadata) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{33} + return file_raft_cmd_proto_rawDescGZIP(), []int{32} } func (x *MirrorDeletedMetadata) GetTarget() *commonpb.Target { @@ -2487,7 +2429,7 @@ type PromoteLedgerOrder struct { func (x *PromoteLedgerOrder) Reset() { *x = PromoteLedgerOrder{} - mi := &file_raft_cmd_proto_msgTypes[34] + mi := &file_raft_cmd_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2499,7 +2441,7 @@ func (x *PromoteLedgerOrder) String() string { func (*PromoteLedgerOrder) ProtoMessage() {} func (x *PromoteLedgerOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[34] + mi := &file_raft_cmd_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2512,7 +2454,7 @@ func (x *PromoteLedgerOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use PromoteLedgerOrder.ProtoReflect.Descriptor instead. func (*PromoteLedgerOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{34} + return file_raft_cmd_proto_rawDescGZIP(), []int{33} } type DeleteLedgerOrder struct { @@ -2523,7 +2465,7 @@ type DeleteLedgerOrder struct { func (x *DeleteLedgerOrder) Reset() { *x = DeleteLedgerOrder{} - mi := &file_raft_cmd_proto_msgTypes[35] + mi := &file_raft_cmd_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2535,7 +2477,7 @@ func (x *DeleteLedgerOrder) String() string { func (*DeleteLedgerOrder) ProtoMessage() {} func (x *DeleteLedgerOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[35] + mi := &file_raft_cmd_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2548,7 +2490,7 @@ func (x *DeleteLedgerOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteLedgerOrder.ProtoReflect.Descriptor instead. func (*DeleteLedgerOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{35} + return file_raft_cmd_proto_rawDescGZIP(), []int{34} } type LedgerApplyOrder struct { @@ -2598,7 +2540,7 @@ type LedgerApplyOrder struct { func (x *LedgerApplyOrder) Reset() { *x = LedgerApplyOrder{} - mi := &file_raft_cmd_proto_msgTypes[36] + mi := &file_raft_cmd_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2610,7 +2552,7 @@ func (x *LedgerApplyOrder) String() string { func (*LedgerApplyOrder) ProtoMessage() {} func (x *LedgerApplyOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[36] + mi := &file_raft_cmd_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2623,7 +2565,7 @@ func (x *LedgerApplyOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use LedgerApplyOrder.ProtoReflect.Descriptor instead. func (*LedgerApplyOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{36} + return file_raft_cmd_proto_rawDescGZIP(), []int{35} } func (x *LedgerApplyOrder) GetData() isLedgerApplyOrder_Data { @@ -2819,7 +2761,7 @@ type CreateIndexOrder struct { func (x *CreateIndexOrder) Reset() { *x = CreateIndexOrder{} - mi := &file_raft_cmd_proto_msgTypes[37] + mi := &file_raft_cmd_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2831,7 +2773,7 @@ func (x *CreateIndexOrder) String() string { func (*CreateIndexOrder) ProtoMessage() {} func (x *CreateIndexOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[37] + mi := &file_raft_cmd_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2844,7 +2786,7 @@ func (x *CreateIndexOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateIndexOrder.ProtoReflect.Descriptor instead. func (*CreateIndexOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{37} + return file_raft_cmd_proto_rawDescGZIP(), []int{36} } func (x *CreateIndexOrder) GetId() *commonpb.IndexID { @@ -2864,7 +2806,7 @@ type DropIndexOrder struct { func (x *DropIndexOrder) Reset() { *x = DropIndexOrder{} - mi := &file_raft_cmd_proto_msgTypes[38] + mi := &file_raft_cmd_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2876,7 +2818,7 @@ func (x *DropIndexOrder) String() string { func (*DropIndexOrder) ProtoMessage() {} func (x *DropIndexOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[38] + mi := &file_raft_cmd_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2889,7 +2831,7 @@ func (x *DropIndexOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use DropIndexOrder.ProtoReflect.Descriptor instead. func (*DropIndexOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{38} + return file_raft_cmd_proto_rawDescGZIP(), []int{37} } func (x *DropIndexOrder) GetId() *commonpb.IndexID { @@ -2909,7 +2851,7 @@ type AddAccountTypeOrder struct { func (x *AddAccountTypeOrder) Reset() { *x = AddAccountTypeOrder{} - mi := &file_raft_cmd_proto_msgTypes[39] + mi := &file_raft_cmd_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2921,7 +2863,7 @@ func (x *AddAccountTypeOrder) String() string { func (*AddAccountTypeOrder) ProtoMessage() {} func (x *AddAccountTypeOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[39] + mi := &file_raft_cmd_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2934,7 +2876,7 @@ func (x *AddAccountTypeOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAccountTypeOrder.ProtoReflect.Descriptor instead. func (*AddAccountTypeOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{39} + return file_raft_cmd_proto_rawDescGZIP(), []int{38} } func (x *AddAccountTypeOrder) GetAccountType() *commonpb.AccountType { @@ -2954,7 +2896,7 @@ type RemoveAccountTypeOrder struct { func (x *RemoveAccountTypeOrder) Reset() { *x = RemoveAccountTypeOrder{} - mi := &file_raft_cmd_proto_msgTypes[40] + mi := &file_raft_cmd_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2966,7 +2908,7 @@ func (x *RemoveAccountTypeOrder) String() string { func (*RemoveAccountTypeOrder) ProtoMessage() {} func (x *RemoveAccountTypeOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[40] + mi := &file_raft_cmd_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2979,7 +2921,7 @@ func (x *RemoveAccountTypeOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveAccountTypeOrder.ProtoReflect.Descriptor instead. func (*RemoveAccountTypeOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{40} + return file_raft_cmd_proto_rawDescGZIP(), []int{39} } func (x *RemoveAccountTypeOrder) GetName() string { @@ -2999,7 +2941,7 @@ type UpdateDefaultEnforcementModeOrder struct { func (x *UpdateDefaultEnforcementModeOrder) Reset() { *x = UpdateDefaultEnforcementModeOrder{} - mi := &file_raft_cmd_proto_msgTypes[41] + mi := &file_raft_cmd_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3011,7 +2953,7 @@ func (x *UpdateDefaultEnforcementModeOrder) String() string { func (*UpdateDefaultEnforcementModeOrder) ProtoMessage() {} func (x *UpdateDefaultEnforcementModeOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[41] + mi := &file_raft_cmd_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3024,7 +2966,7 @@ func (x *UpdateDefaultEnforcementModeOrder) ProtoReflect() protoreflect.Message // Deprecated: Use UpdateDefaultEnforcementModeOrder.ProtoReflect.Descriptor instead. func (*UpdateDefaultEnforcementModeOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{41} + return file_raft_cmd_proto_rawDescGZIP(), []int{40} } func (x *UpdateDefaultEnforcementModeOrder) GetEnforcementMode() commonpb.ChartEnforcementMode { @@ -3045,7 +2987,7 @@ type SetMetadataFieldTypeOrder struct { func (x *SetMetadataFieldTypeOrder) Reset() { *x = SetMetadataFieldTypeOrder{} - mi := &file_raft_cmd_proto_msgTypes[42] + mi := &file_raft_cmd_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3057,7 +2999,7 @@ func (x *SetMetadataFieldTypeOrder) String() string { func (*SetMetadataFieldTypeOrder) ProtoMessage() {} func (x *SetMetadataFieldTypeOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[42] + mi := &file_raft_cmd_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3070,7 +3012,7 @@ func (x *SetMetadataFieldTypeOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use SetMetadataFieldTypeOrder.ProtoReflect.Descriptor instead. func (*SetMetadataFieldTypeOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{42} + return file_raft_cmd_proto_rawDescGZIP(), []int{41} } func (x *SetMetadataFieldTypeOrder) GetTargetType() commonpb.TargetType { @@ -3104,7 +3046,7 @@ type RemoveMetadataFieldTypeOrder struct { func (x *RemoveMetadataFieldTypeOrder) Reset() { *x = RemoveMetadataFieldTypeOrder{} - mi := &file_raft_cmd_proto_msgTypes[43] + mi := &file_raft_cmd_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3116,7 +3058,7 @@ func (x *RemoveMetadataFieldTypeOrder) String() string { func (*RemoveMetadataFieldTypeOrder) ProtoMessage() {} func (x *RemoveMetadataFieldTypeOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[43] + mi := &file_raft_cmd_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3129,7 +3071,7 @@ func (x *RemoveMetadataFieldTypeOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveMetadataFieldTypeOrder.ProtoReflect.Descriptor instead. func (*RemoveMetadataFieldTypeOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{43} + return file_raft_cmd_proto_rawDescGZIP(), []int{42} } func (x *RemoveMetadataFieldTypeOrder) GetTargetType() commonpb.TargetType { @@ -3163,7 +3105,7 @@ type CreateTransactionOrder struct { func (x *CreateTransactionOrder) Reset() { *x = CreateTransactionOrder{} - mi := &file_raft_cmd_proto_msgTypes[44] + mi := &file_raft_cmd_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3175,7 +3117,7 @@ func (x *CreateTransactionOrder) String() string { func (*CreateTransactionOrder) ProtoMessage() {} func (x *CreateTransactionOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[44] + mi := &file_raft_cmd_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3188,7 +3130,7 @@ func (x *CreateTransactionOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateTransactionOrder.ProtoReflect.Descriptor instead. func (*CreateTransactionOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{44} + return file_raft_cmd_proto_rawDescGZIP(), []int{43} } func (x *CreateTransactionOrder) GetPostings() []*commonpb.Posting { @@ -3254,8 +3196,11 @@ func (x *CreateTransactionOrder) GetNumscriptReference() *NumscriptReference { return nil } -// NumscriptReference identifies a numscript from the library to use for a transaction. -// The version is resolved by admission (fuzzy → exact) before entering the Raft log. +// NumscriptReference identifies a numscript from the library to use for a +// transaction. The version selector — "" / "latest" or an exact full semver +// (partial selectors are read-only, rejected here) — is carried verbatim into +// the audited order; admission only plans the reads, and the FSM resolves +// "latest" to the greatest stored semver at apply. type NumscriptReference struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -3267,7 +3212,7 @@ type NumscriptReference struct { func (x *NumscriptReference) Reset() { *x = NumscriptReference{} - mi := &file_raft_cmd_proto_msgTypes[45] + mi := &file_raft_cmd_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3279,7 +3224,7 @@ func (x *NumscriptReference) String() string { func (*NumscriptReference) ProtoMessage() {} func (x *NumscriptReference) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[45] + mi := &file_raft_cmd_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3292,7 +3237,7 @@ func (x *NumscriptReference) ProtoReflect() protoreflect.Message { // Deprecated: Use NumscriptReference.ProtoReflect.Descriptor instead. func (*NumscriptReference) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{45} + return file_raft_cmd_proto_rawDescGZIP(), []int{44} } func (x *NumscriptReference) GetName() string { @@ -3326,7 +3271,7 @@ type SaveMetadataOrder struct { func (x *SaveMetadataOrder) Reset() { *x = SaveMetadataOrder{} - mi := &file_raft_cmd_proto_msgTypes[46] + mi := &file_raft_cmd_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3338,7 +3283,7 @@ func (x *SaveMetadataOrder) String() string { func (*SaveMetadataOrder) ProtoMessage() {} func (x *SaveMetadataOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[46] + mi := &file_raft_cmd_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3351,7 +3296,7 @@ func (x *SaveMetadataOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use SaveMetadataOrder.ProtoReflect.Descriptor instead. func (*SaveMetadataOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{46} + return file_raft_cmd_proto_rawDescGZIP(), []int{45} } func (x *SaveMetadataOrder) GetTarget() *commonpb.Target { @@ -3382,7 +3327,7 @@ type RevertTransactionOrder struct { func (x *RevertTransactionOrder) Reset() { *x = RevertTransactionOrder{} - mi := &file_raft_cmd_proto_msgTypes[47] + mi := &file_raft_cmd_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3394,7 +3339,7 @@ func (x *RevertTransactionOrder) String() string { func (*RevertTransactionOrder) ProtoMessage() {} func (x *RevertTransactionOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[47] + mi := &file_raft_cmd_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3407,7 +3352,7 @@ func (x *RevertTransactionOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use RevertTransactionOrder.ProtoReflect.Descriptor instead. func (*RevertTransactionOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{47} + return file_raft_cmd_proto_rawDescGZIP(), []int{46} } func (x *RevertTransactionOrder) GetTransactionId() uint64 { @@ -3462,7 +3407,7 @@ type DeleteMetadataOrder struct { func (x *DeleteMetadataOrder) Reset() { *x = DeleteMetadataOrder{} - mi := &file_raft_cmd_proto_msgTypes[48] + mi := &file_raft_cmd_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3474,7 +3419,7 @@ func (x *DeleteMetadataOrder) String() string { func (*DeleteMetadataOrder) ProtoMessage() {} func (x *DeleteMetadataOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[48] + mi := &file_raft_cmd_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3487,7 +3432,7 @@ func (x *DeleteMetadataOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteMetadataOrder.ProtoReflect.Descriptor instead. func (*DeleteMetadataOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{48} + return file_raft_cmd_proto_rawDescGZIP(), []int{47} } func (x *DeleteMetadataOrder) GetTarget() *commonpb.Target { @@ -3514,7 +3459,7 @@ type SaveLedgerMetadataOrder struct { func (x *SaveLedgerMetadataOrder) Reset() { *x = SaveLedgerMetadataOrder{} - mi := &file_raft_cmd_proto_msgTypes[49] + mi := &file_raft_cmd_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3526,7 +3471,7 @@ func (x *SaveLedgerMetadataOrder) String() string { func (*SaveLedgerMetadataOrder) ProtoMessage() {} func (x *SaveLedgerMetadataOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[49] + mi := &file_raft_cmd_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3539,7 +3484,7 @@ func (x *SaveLedgerMetadataOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use SaveLedgerMetadataOrder.ProtoReflect.Descriptor instead. func (*SaveLedgerMetadataOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{49} + return file_raft_cmd_proto_rawDescGZIP(), []int{48} } func (x *SaveLedgerMetadataOrder) GetMetadata() map[string]*commonpb.MetadataValue { @@ -3559,7 +3504,7 @@ type DeleteLedgerMetadataOrder struct { func (x *DeleteLedgerMetadataOrder) Reset() { *x = DeleteLedgerMetadataOrder{} - mi := &file_raft_cmd_proto_msgTypes[50] + mi := &file_raft_cmd_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3571,7 +3516,7 @@ func (x *DeleteLedgerMetadataOrder) String() string { func (*DeleteLedgerMetadataOrder) ProtoMessage() {} func (x *DeleteLedgerMetadataOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[50] + mi := &file_raft_cmd_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3584,7 +3529,7 @@ func (x *DeleteLedgerMetadataOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteLedgerMetadataOrder.ProtoReflect.Descriptor instead. func (*DeleteLedgerMetadataOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{50} + return file_raft_cmd_proto_rawDescGZIP(), []int{49} } func (x *DeleteLedgerMetadataOrder) GetKey() string { @@ -3630,7 +3575,7 @@ type Proposal struct { func (x *Proposal) Reset() { *x = Proposal{} - mi := &file_raft_cmd_proto_msgTypes[51] + mi := &file_raft_cmd_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3642,7 +3587,7 @@ func (x *Proposal) String() string { func (*Proposal) ProtoMessage() {} func (x *Proposal) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[51] + mi := &file_raft_cmd_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3655,7 +3600,7 @@ func (x *Proposal) ProtoReflect() protoreflect.Message { // Deprecated: Use Proposal.ProtoReflect.Descriptor instead. func (*Proposal) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{51} + return file_raft_cmd_proto_rawDescGZIP(), []int{50} } func (x *Proposal) GetId() uint64 { @@ -3746,7 +3691,7 @@ type TechnicalUpdate struct { func (x *TechnicalUpdate) Reset() { *x = TechnicalUpdate{} - mi := &file_raft_cmd_proto_msgTypes[52] + mi := &file_raft_cmd_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3758,7 +3703,7 @@ func (x *TechnicalUpdate) String() string { func (*TechnicalUpdate) ProtoMessage() {} func (x *TechnicalUpdate) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[52] + mi := &file_raft_cmd_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3771,7 +3716,7 @@ func (x *TechnicalUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use TechnicalUpdate.ProtoReflect.Descriptor instead. func (*TechnicalUpdate) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{52} + return file_raft_cmd_proto_rawDescGZIP(), []int{51} } func (x *TechnicalUpdate) GetCoverageBits() []byte { @@ -3911,7 +3856,7 @@ type BackupDestination struct { func (x *BackupDestination) Reset() { *x = BackupDestination{} - mi := &file_raft_cmd_proto_msgTypes[53] + mi := &file_raft_cmd_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3923,7 +3868,7 @@ func (x *BackupDestination) String() string { func (*BackupDestination) ProtoMessage() {} func (x *BackupDestination) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[53] + mi := &file_raft_cmd_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3936,7 +3881,7 @@ func (x *BackupDestination) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupDestination.ProtoReflect.Descriptor instead. func (*BackupDestination) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{53} + return file_raft_cmd_proto_rawDescGZIP(), []int{52} } func (x *BackupDestination) GetBasePath() string { @@ -4005,7 +3950,7 @@ type S3BackupTarget struct { func (x *S3BackupTarget) Reset() { *x = S3BackupTarget{} - mi := &file_raft_cmd_proto_msgTypes[54] + mi := &file_raft_cmd_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4017,7 +3962,7 @@ func (x *S3BackupTarget) String() string { func (*S3BackupTarget) ProtoMessage() {} func (x *S3BackupTarget) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[54] + mi := &file_raft_cmd_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4030,7 +3975,7 @@ func (x *S3BackupTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use S3BackupTarget.ProtoReflect.Descriptor instead. func (*S3BackupTarget) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{54} + return file_raft_cmd_proto_rawDescGZIP(), []int{53} } func (x *S3BackupTarget) GetBucket() string { @@ -4065,7 +4010,7 @@ type AzureBackupTarget struct { func (x *AzureBackupTarget) Reset() { *x = AzureBackupTarget{} - mi := &file_raft_cmd_proto_msgTypes[55] + mi := &file_raft_cmd_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4077,7 +4022,7 @@ func (x *AzureBackupTarget) String() string { func (*AzureBackupTarget) ProtoMessage() {} func (x *AzureBackupTarget) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[55] + mi := &file_raft_cmd_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4090,7 +4035,7 @@ func (x *AzureBackupTarget) ProtoReflect() protoreflect.Message { // Deprecated: Use AzureBackupTarget.ProtoReflect.Descriptor instead. func (*AzureBackupTarget) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{55} + return file_raft_cmd_proto_rawDescGZIP(), []int{54} } func (x *AzureBackupTarget) GetAccountName() string { @@ -4165,7 +4110,7 @@ type BackupJob struct { func (x *BackupJob) Reset() { *x = BackupJob{} - mi := &file_raft_cmd_proto_msgTypes[56] + mi := &file_raft_cmd_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4177,7 +4122,7 @@ func (x *BackupJob) String() string { func (*BackupJob) ProtoMessage() {} func (x *BackupJob) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[56] + mi := &file_raft_cmd_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4190,7 +4135,7 @@ func (x *BackupJob) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupJob.ProtoReflect.Descriptor instead. func (*BackupJob) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{56} + return file_raft_cmd_proto_rawDescGZIP(), []int{55} } func (x *BackupJob) GetJobId() uint64 { @@ -4307,7 +4252,7 @@ type BackupOrder struct { func (x *BackupOrder) Reset() { *x = BackupOrder{} - mi := &file_raft_cmd_proto_msgTypes[57] + mi := &file_raft_cmd_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4319,7 +4264,7 @@ func (x *BackupOrder) String() string { func (*BackupOrder) ProtoMessage() {} func (x *BackupOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[57] + mi := &file_raft_cmd_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4332,7 +4277,7 @@ func (x *BackupOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupOrder.ProtoReflect.Descriptor instead. func (*BackupOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{57} + return file_raft_cmd_proto_rawDescGZIP(), []int{56} } func (x *BackupOrder) GetOp() isBackupOrder_Op { @@ -4409,7 +4354,7 @@ type IncrementalBackupOrder struct { func (x *IncrementalBackupOrder) Reset() { *x = IncrementalBackupOrder{} - mi := &file_raft_cmd_proto_msgTypes[58] + mi := &file_raft_cmd_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4421,7 +4366,7 @@ func (x *IncrementalBackupOrder) String() string { func (*IncrementalBackupOrder) ProtoMessage() {} func (x *IncrementalBackupOrder) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[58] + mi := &file_raft_cmd_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4434,7 +4379,7 @@ func (x *IncrementalBackupOrder) ProtoReflect() protoreflect.Message { // Deprecated: Use IncrementalBackupOrder.ProtoReflect.Descriptor instead. func (*IncrementalBackupOrder) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{58} + return file_raft_cmd_proto_rawDescGZIP(), []int{57} } func (x *IncrementalBackupOrder) GetOp() isIncrementalBackupOrder_Op { @@ -4508,7 +4453,7 @@ type BackupOrderStart struct { func (x *BackupOrderStart) Reset() { *x = BackupOrderStart{} - mi := &file_raft_cmd_proto_msgTypes[59] + mi := &file_raft_cmd_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4520,7 +4465,7 @@ func (x *BackupOrderStart) String() string { func (*BackupOrderStart) ProtoMessage() {} func (x *BackupOrderStart) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[59] + mi := &file_raft_cmd_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4533,7 +4478,7 @@ func (x *BackupOrderStart) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupOrderStart.ProtoReflect.Descriptor instead. func (*BackupOrderStart) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{59} + return file_raft_cmd_proto_rawDescGZIP(), []int{58} } func (x *BackupOrderStart) GetJobId() uint64 { @@ -4576,7 +4521,7 @@ type BackupOrderComplete struct { func (x *BackupOrderComplete) Reset() { *x = BackupOrderComplete{} - mi := &file_raft_cmd_proto_msgTypes[60] + mi := &file_raft_cmd_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4588,7 +4533,7 @@ func (x *BackupOrderComplete) String() string { func (*BackupOrderComplete) ProtoMessage() {} func (x *BackupOrderComplete) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[60] + mi := &file_raft_cmd_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4601,7 +4546,7 @@ func (x *BackupOrderComplete) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupOrderComplete.ProtoReflect.Descriptor instead. func (*BackupOrderComplete) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{60} + return file_raft_cmd_proto_rawDescGZIP(), []int{59} } func (x *BackupOrderComplete) GetJobId() uint64 { @@ -4658,7 +4603,7 @@ type BackupOrderFail struct { func (x *BackupOrderFail) Reset() { *x = BackupOrderFail{} - mi := &file_raft_cmd_proto_msgTypes[61] + mi := &file_raft_cmd_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4670,7 +4615,7 @@ func (x *BackupOrderFail) String() string { func (*BackupOrderFail) ProtoMessage() {} func (x *BackupOrderFail) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[61] + mi := &file_raft_cmd_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4683,7 +4628,7 @@ func (x *BackupOrderFail) ProtoReflect() protoreflect.Message { // Deprecated: Use BackupOrderFail.ProtoReflect.Descriptor instead. func (*BackupOrderFail) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{61} + return file_raft_cmd_proto_rawDescGZIP(), []int{60} } func (x *BackupOrderFail) GetJobId() uint64 { @@ -4721,7 +4666,7 @@ type IdempotencyEviction struct { func (x *IdempotencyEviction) Reset() { *x = IdempotencyEviction{} - mi := &file_raft_cmd_proto_msgTypes[62] + mi := &file_raft_cmd_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4733,7 +4678,7 @@ func (x *IdempotencyEviction) String() string { func (*IdempotencyEviction) ProtoMessage() {} func (x *IdempotencyEviction) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[62] + mi := &file_raft_cmd_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4746,7 +4691,7 @@ func (x *IdempotencyEviction) ProtoReflect() protoreflect.Message { // Deprecated: Use IdempotencyEviction.ProtoReflect.Descriptor instead. func (*IdempotencyEviction) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{62} + return file_raft_cmd_proto_rawDescGZIP(), []int{61} } func (x *IdempotencyEviction) GetCutoffMicros() uint64 { @@ -4783,7 +4728,7 @@ type MirrorSyncUpdate struct { func (x *MirrorSyncUpdate) Reset() { *x = MirrorSyncUpdate{} - mi := &file_raft_cmd_proto_msgTypes[63] + mi := &file_raft_cmd_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4795,7 +4740,7 @@ func (x *MirrorSyncUpdate) String() string { func (*MirrorSyncUpdate) ProtoMessage() {} func (x *MirrorSyncUpdate) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[63] + mi := &file_raft_cmd_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4808,7 +4753,7 @@ func (x *MirrorSyncUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use MirrorSyncUpdate.ProtoReflect.Descriptor instead. func (*MirrorSyncUpdate) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{63} + return file_raft_cmd_proto_rawDescGZIP(), []int{62} } func (x *MirrorSyncUpdate) GetLedgerName() string { @@ -4859,7 +4804,7 @@ type EventsSinkUpdate struct { func (x *EventsSinkUpdate) Reset() { *x = EventsSinkUpdate{} - mi := &file_raft_cmd_proto_msgTypes[64] + mi := &file_raft_cmd_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4871,7 +4816,7 @@ func (x *EventsSinkUpdate) String() string { func (*EventsSinkUpdate) ProtoMessage() {} func (x *EventsSinkUpdate) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[64] + mi := &file_raft_cmd_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4884,7 +4829,7 @@ func (x *EventsSinkUpdate) ProtoReflect() protoreflect.Message { // Deprecated: Use EventsSinkUpdate.ProtoReflect.Descriptor instead. func (*EventsSinkUpdate) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{64} + return file_raft_cmd_proto_rawDescGZIP(), []int{63} } func (x *EventsSinkUpdate) GetSinkName() string { @@ -4928,7 +4873,7 @@ type CreatedLogOrReference struct { func (x *CreatedLogOrReference) Reset() { *x = CreatedLogOrReference{} - mi := &file_raft_cmd_proto_msgTypes[65] + mi := &file_raft_cmd_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4940,7 +4885,7 @@ func (x *CreatedLogOrReference) String() string { func (*CreatedLogOrReference) ProtoMessage() {} func (x *CreatedLogOrReference) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[65] + mi := &file_raft_cmd_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4953,7 +4898,7 @@ func (x *CreatedLogOrReference) ProtoReflect() protoreflect.Message { // Deprecated: Use CreatedLogOrReference.ProtoReflect.Descriptor instead. func (*CreatedLogOrReference) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{65} + return file_raft_cmd_proto_rawDescGZIP(), []int{64} } func (x *CreatedLogOrReference) GetType() isCreatedLogOrReference_Type { @@ -5011,7 +4956,7 @@ type LedgerBoundaries struct { func (x *LedgerBoundaries) Reset() { *x = LedgerBoundaries{} - mi := &file_raft_cmd_proto_msgTypes[66] + mi := &file_raft_cmd_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5023,7 +4968,7 @@ func (x *LedgerBoundaries) String() string { func (*LedgerBoundaries) ProtoMessage() {} func (x *LedgerBoundaries) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[66] + mi := &file_raft_cmd_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5036,7 +4981,7 @@ func (x *LedgerBoundaries) ProtoReflect() protoreflect.Message { // Deprecated: Use LedgerBoundaries.ProtoReflect.Descriptor instead. func (*LedgerBoundaries) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{66} + return file_raft_cmd_proto_rawDescGZIP(), []int{65} } func (x *LedgerBoundaries) GetNextTransactionId() uint64 { @@ -5070,7 +5015,7 @@ type VolumePair struct { func (x *VolumePair) Reset() { *x = VolumePair{} - mi := &file_raft_cmd_proto_msgTypes[67] + mi := &file_raft_cmd_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5082,7 +5027,7 @@ func (x *VolumePair) String() string { func (*VolumePair) ProtoMessage() {} func (x *VolumePair) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[67] + mi := &file_raft_cmd_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5095,7 +5040,7 @@ func (x *VolumePair) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumePair.ProtoReflect.Descriptor instead. func (*VolumePair) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{67} + return file_raft_cmd_proto_rawDescGZIP(), []int{66} } func (x *VolumePair) GetInput() *commonpb.Uint256 { @@ -5144,7 +5089,7 @@ type ExecutionPlan struct { func (x *ExecutionPlan) Reset() { *x = ExecutionPlan{} - mi := &file_raft_cmd_proto_msgTypes[68] + mi := &file_raft_cmd_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5156,7 +5101,7 @@ func (x *ExecutionPlan) String() string { func (*ExecutionPlan) ProtoMessage() {} func (x *ExecutionPlan) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[68] + mi := &file_raft_cmd_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5169,7 +5114,7 @@ func (x *ExecutionPlan) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecutionPlan.ProtoReflect.Descriptor instead. func (*ExecutionPlan) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{68} + return file_raft_cmd_proto_rawDescGZIP(), []int{67} } func (x *ExecutionPlan) GetLastPersistedIndex() uint64 { @@ -5220,7 +5165,7 @@ type AttributeCoverage struct { func (x *AttributeCoverage) Reset() { *x = AttributeCoverage{} - mi := &file_raft_cmd_proto_msgTypes[69] + mi := &file_raft_cmd_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5232,7 +5177,7 @@ func (x *AttributeCoverage) String() string { func (*AttributeCoverage) ProtoMessage() {} func (x *AttributeCoverage) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[69] + mi := &file_raft_cmd_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5245,7 +5190,7 @@ func (x *AttributeCoverage) ProtoReflect() protoreflect.Message { // Deprecated: Use AttributeCoverage.ProtoReflect.Descriptor instead. func (*AttributeCoverage) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{69} + return file_raft_cmd_proto_rawDescGZIP(), []int{68} } func (x *AttributeCoverage) GetId() *AttributeID { @@ -5283,7 +5228,7 @@ type AttributeValue struct { func (x *AttributeValue) Reset() { *x = AttributeValue{} - mi := &file_raft_cmd_proto_msgTypes[70] + mi := &file_raft_cmd_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5295,7 +5240,7 @@ func (x *AttributeValue) String() string { func (*AttributeValue) ProtoMessage() {} func (x *AttributeValue) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[70] + mi := &file_raft_cmd_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5308,7 +5253,7 @@ func (x *AttributeValue) ProtoReflect() protoreflect.Message { // Deprecated: Use AttributeValue.ProtoReflect.Descriptor instead. func (*AttributeValue) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{70} + return file_raft_cmd_proto_rawDescGZIP(), []int{69} } func (x *AttributeValue) GetRawValue() []byte { @@ -5333,7 +5278,7 @@ type ReloadIdempotencyKey struct { func (x *ReloadIdempotencyKey) Reset() { *x = ReloadIdempotencyKey{} - mi := &file_raft_cmd_proto_msgTypes[71] + mi := &file_raft_cmd_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5345,7 +5290,7 @@ func (x *ReloadIdempotencyKey) String() string { func (*ReloadIdempotencyKey) ProtoMessage() {} func (x *ReloadIdempotencyKey) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[71] + mi := &file_raft_cmd_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5358,7 +5303,7 @@ func (x *ReloadIdempotencyKey) ProtoReflect() protoreflect.Message { // Deprecated: Use ReloadIdempotencyKey.ProtoReflect.Descriptor instead. func (*ReloadIdempotencyKey) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{71} + return file_raft_cmd_proto_rawDescGZIP(), []int{70} } func (x *ReloadIdempotencyKey) GetKey() string { @@ -5385,7 +5330,7 @@ type CacheGenerationMeta struct { func (x *CacheGenerationMeta) Reset() { *x = CacheGenerationMeta{} - mi := &file_raft_cmd_proto_msgTypes[72] + mi := &file_raft_cmd_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5397,7 +5342,7 @@ func (x *CacheGenerationMeta) String() string { func (*CacheGenerationMeta) ProtoMessage() {} func (x *CacheGenerationMeta) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[72] + mi := &file_raft_cmd_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5410,7 +5355,7 @@ func (x *CacheGenerationMeta) ProtoReflect() protoreflect.Message { // Deprecated: Use CacheGenerationMeta.ProtoReflect.Descriptor instead. func (*CacheGenerationMeta) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{72} + return file_raft_cmd_proto_rawDescGZIP(), []int{71} } func (x *CacheGenerationMeta) GetBaseIndex() uint64 { @@ -5430,7 +5375,7 @@ type CacheSnapshotMeta struct { func (x *CacheSnapshotMeta) Reset() { *x = CacheSnapshotMeta{} - mi := &file_raft_cmd_proto_msgTypes[73] + mi := &file_raft_cmd_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5442,7 +5387,7 @@ func (x *CacheSnapshotMeta) String() string { func (*CacheSnapshotMeta) ProtoMessage() {} func (x *CacheSnapshotMeta) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[73] + mi := &file_raft_cmd_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5455,7 +5400,7 @@ func (x *CacheSnapshotMeta) ProtoReflect() protoreflect.Message { // Deprecated: Use CacheSnapshotMeta.ProtoReflect.Descriptor instead. func (*CacheSnapshotMeta) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{73} + return file_raft_cmd_proto_rawDescGZIP(), []int{72} } func (x *CacheSnapshotMeta) GetCurrentGeneration() uint64 { @@ -5485,7 +5430,7 @@ type PeerAddress struct { func (x *PeerAddress) Reset() { *x = PeerAddress{} - mi := &file_raft_cmd_proto_msgTypes[74] + mi := &file_raft_cmd_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5497,7 +5442,7 @@ func (x *PeerAddress) String() string { func (*PeerAddress) ProtoMessage() {} func (x *PeerAddress) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[74] + mi := &file_raft_cmd_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5510,7 +5455,7 @@ func (x *PeerAddress) ProtoReflect() protoreflect.Message { // Deprecated: Use PeerAddress.ProtoReflect.Descriptor instead. func (*PeerAddress) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{74} + return file_raft_cmd_proto_rawDescGZIP(), []int{73} } func (x *PeerAddress) GetNodeId() uint64 { @@ -5558,7 +5503,7 @@ type RemovedMemberEntry struct { func (x *RemovedMemberEntry) Reset() { *x = RemovedMemberEntry{} - mi := &file_raft_cmd_proto_msgTypes[75] + mi := &file_raft_cmd_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5570,7 +5515,7 @@ func (x *RemovedMemberEntry) String() string { func (*RemovedMemberEntry) ProtoMessage() {} func (x *RemovedMemberEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[75] + mi := &file_raft_cmd_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5583,7 +5528,7 @@ func (x *RemovedMemberEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use RemovedMemberEntry.ProtoReflect.Descriptor instead. func (*RemovedMemberEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{75} + return file_raft_cmd_proto_rawDescGZIP(), []int{74} } func (x *RemovedMemberEntry) GetNodeId() uint64 { @@ -5630,7 +5575,7 @@ type GenerationSnapshot struct { func (x *GenerationSnapshot) Reset() { *x = GenerationSnapshot{} - mi := &file_raft_cmd_proto_msgTypes[76] + mi := &file_raft_cmd_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5642,7 +5587,7 @@ func (x *GenerationSnapshot) String() string { func (*GenerationSnapshot) ProtoMessage() {} func (x *GenerationSnapshot) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[76] + mi := &file_raft_cmd_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5655,7 +5600,7 @@ func (x *GenerationSnapshot) ProtoReflect() protoreflect.Message { // Deprecated: Use GenerationSnapshot.ProtoReflect.Descriptor instead. func (*GenerationSnapshot) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{76} + return file_raft_cmd_proto_rawDescGZIP(), []int{75} } func (x *GenerationSnapshot) GetBaseIndex() uint64 { @@ -5726,7 +5671,7 @@ type VolumeAttributeSnapshotEntry struct { func (x *VolumeAttributeSnapshotEntry) Reset() { *x = VolumeAttributeSnapshotEntry{} - mi := &file_raft_cmd_proto_msgTypes[77] + mi := &file_raft_cmd_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5738,7 +5683,7 @@ func (x *VolumeAttributeSnapshotEntry) String() string { func (*VolumeAttributeSnapshotEntry) ProtoMessage() {} func (x *VolumeAttributeSnapshotEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[77] + mi := &file_raft_cmd_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5751,7 +5696,7 @@ func (x *VolumeAttributeSnapshotEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumeAttributeSnapshotEntry.ProtoReflect.Descriptor instead. func (*VolumeAttributeSnapshotEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{77} + return file_raft_cmd_proto_rawDescGZIP(), []int{76} } func (x *VolumeAttributeSnapshotEntry) GetId() *AttributeID { @@ -5786,7 +5731,7 @@ type MetadataAttributeEntry struct { func (x *MetadataAttributeEntry) Reset() { *x = MetadataAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[78] + mi := &file_raft_cmd_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5798,7 +5743,7 @@ func (x *MetadataAttributeEntry) String() string { func (*MetadataAttributeEntry) ProtoMessage() {} func (x *MetadataAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[78] + mi := &file_raft_cmd_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5811,7 +5756,7 @@ func (x *MetadataAttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use MetadataAttributeEntry.ProtoReflect.Descriptor instead. func (*MetadataAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{78} + return file_raft_cmd_proto_rawDescGZIP(), []int{77} } func (x *MetadataAttributeEntry) GetId() *AttributeID { @@ -5839,7 +5784,7 @@ type LedgerAttributeEntry struct { func (x *LedgerAttributeEntry) Reset() { *x = LedgerAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[79] + mi := &file_raft_cmd_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5851,7 +5796,7 @@ func (x *LedgerAttributeEntry) String() string { func (*LedgerAttributeEntry) ProtoMessage() {} func (x *LedgerAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[79] + mi := &file_raft_cmd_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5864,7 +5809,7 @@ func (x *LedgerAttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use LedgerAttributeEntry.ProtoReflect.Descriptor instead. func (*LedgerAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{79} + return file_raft_cmd_proto_rawDescGZIP(), []int{78} } func (x *LedgerAttributeEntry) GetId() *AttributeID { @@ -5892,7 +5837,7 @@ type BoundaryAttributeEntry struct { func (x *BoundaryAttributeEntry) Reset() { *x = BoundaryAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[80] + mi := &file_raft_cmd_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5904,7 +5849,7 @@ func (x *BoundaryAttributeEntry) String() string { func (*BoundaryAttributeEntry) ProtoMessage() {} func (x *BoundaryAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[80] + mi := &file_raft_cmd_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5917,7 +5862,7 @@ func (x *BoundaryAttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use BoundaryAttributeEntry.ProtoReflect.Descriptor instead. func (*BoundaryAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{80} + return file_raft_cmd_proto_rawDescGZIP(), []int{79} } func (x *BoundaryAttributeEntry) GetId() *AttributeID { @@ -5945,7 +5890,7 @@ type TransactionReferenceAttributeEntry struct { func (x *TransactionReferenceAttributeEntry) Reset() { *x = TransactionReferenceAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[81] + mi := &file_raft_cmd_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5957,7 +5902,7 @@ func (x *TransactionReferenceAttributeEntry) String() string { func (*TransactionReferenceAttributeEntry) ProtoMessage() {} func (x *TransactionReferenceAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[81] + mi := &file_raft_cmd_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5970,7 +5915,7 @@ func (x *TransactionReferenceAttributeEntry) ProtoReflect() protoreflect.Message // Deprecated: Use TransactionReferenceAttributeEntry.ProtoReflect.Descriptor instead. func (*TransactionReferenceAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{81} + return file_raft_cmd_proto_rawDescGZIP(), []int{80} } func (x *TransactionReferenceAttributeEntry) GetId() *AttributeID { @@ -5998,7 +5943,7 @@ type TransactionStateAttributeEntry struct { func (x *TransactionStateAttributeEntry) Reset() { *x = TransactionStateAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[82] + mi := &file_raft_cmd_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6010,7 +5955,7 @@ func (x *TransactionStateAttributeEntry) String() string { func (*TransactionStateAttributeEntry) ProtoMessage() {} func (x *TransactionStateAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[82] + mi := &file_raft_cmd_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6023,7 +5968,7 @@ func (x *TransactionStateAttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use TransactionStateAttributeEntry.ProtoReflect.Descriptor instead. func (*TransactionStateAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{82} + return file_raft_cmd_proto_rawDescGZIP(), []int{81} } func (x *TransactionStateAttributeEntry) GetId() *AttributeID { @@ -6052,7 +5997,7 @@ type IdempotencyKeyAttributeEntry struct { func (x *IdempotencyKeyAttributeEntry) Reset() { *x = IdempotencyKeyAttributeEntry{} - mi := &file_raft_cmd_proto_msgTypes[83] + mi := &file_raft_cmd_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6064,7 +6009,7 @@ func (x *IdempotencyKeyAttributeEntry) String() string { func (*IdempotencyKeyAttributeEntry) ProtoMessage() {} func (x *IdempotencyKeyAttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[83] + mi := &file_raft_cmd_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6077,7 +6022,7 @@ func (x *IdempotencyKeyAttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use IdempotencyKeyAttributeEntry.ProtoReflect.Descriptor instead. func (*IdempotencyKeyAttributeEntry) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{83} + return file_raft_cmd_proto_rawDescGZIP(), []int{82} } func (x *IdempotencyKeyAttributeEntry) GetId() *AttributeID { @@ -6104,7 +6049,7 @@ type AttributeID struct { func (x *AttributeID) Reset() { *x = AttributeID{} - mi := &file_raft_cmd_proto_msgTypes[84] + mi := &file_raft_cmd_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6116,7 +6061,7 @@ func (x *AttributeID) String() string { func (*AttributeID) ProtoMessage() {} func (x *AttributeID) ProtoReflect() protoreflect.Message { - mi := &file_raft_cmd_proto_msgTypes[84] + mi := &file_raft_cmd_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6129,7 +6074,7 @@ func (x *AttributeID) ProtoReflect() protoreflect.Message { // Deprecated: Use AttributeID.ProtoReflect.Descriptor instead. func (*AttributeID) Descriptor() ([]byte, []int) { - return file_raft_cmd_proto_rawDescGZIP(), []int{84} + return file_raft_cmd_proto_rawDescGZIP(), []int{83} } func (x *AttributeID) GetId() []byte { @@ -6159,7 +6104,7 @@ const file_raft_cmd_proto_rawDesc = "" + "\x0eOrderTechnical\x12#\n" + "\rcoverage_bits\x18\x01 \x01(\fR\fcoverageBits\x124\n" + "\x16inputs_resolution_hash\x18\x02 \x01(\fR\x14inputsResolutionHash\x12/\n" + - "\x13preload_unavailable\x18\x03 \x01(\bR\x12preloadUnavailable\"\xa3\a\n" + + "\x13preload_unavailable\x18\x03 \x01(\bR\x12preloadUnavailable\"\xda\x06\n" + "\x11LedgerScopedOrder\x12\x16\n" + "\x06ledger\x18\x01 \x01(\tR\x06ledger\x12.\n" + "\x05apply\x18\x02 \x01(\v2\x16.raft.LedgerApplyOrderH\x00R\x05apply\x12>\n" + @@ -6169,9 +6114,7 @@ const file_raft_cmd_proto_rawDesc = "" + "\x0epromote_ledger\x18\x06 \x01(\v2\x18.raft.PromoteLedgerOrderH\x00R\rpromoteLedger\x12Q\n" + "\x14save_ledger_metadata\x18\a \x01(\v2\x1d.raft.SaveLedgerMetadataOrderH\x00R\x12saveLedgerMetadata\x12W\n" + "\x16delete_ledger_metadata\x18\b \x01(\v2\x1f.raft.DeleteLedgerMetadataOrderH\x00R\x14deleteLedgerMetadata\x12A\n" + - "\x0esave_numscript\x18\t \x01(\v2\x18.raft.SaveNumscriptOrderH\x00R\rsaveNumscript\x12G\n" + - "\x10delete_numscript\x18\n" + - " \x01(\v2\x1a.raft.DeleteNumscriptOrderH\x00R\x0fdeleteNumscript\x12T\n" + + "\x0esave_numscript\x18\t \x01(\v2\x18.raft.SaveNumscriptOrderH\x00R\rsaveNumscript\x12T\n" + "\x15create_prepared_query\x18\v \x01(\v2\x1e.raft.CreatePreparedQueryOrderH\x00R\x13createPreparedQuery\x12T\n" + "\x15update_prepared_query\x18\f \x01(\v2\x1e.raft.UpdatePreparedQueryOrderH\x00R\x13updatePreparedQuery\x12T\n" + "\x15delete_prepared_query\x18\r \x01(\v2\x1e.raft.DeletePreparedQueryOrderH\x00R\x13deletePreparedQueryB\t\n" + @@ -6238,9 +6181,7 @@ const file_raft_cmd_proto_rawDesc = "" + "\x12SaveNumscriptOrder\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" + "\acontent\x18\x02 \x01(\tR\acontent\x12\x18\n" + - "\aversion\x18\x03 \x01(\tR\aversion\"*\n" + - "\x14DeleteNumscriptOrder\x12\x12\n" + - "\x04name\x18\x01 \x01(\tR\x04name\"\x1c\n" + + "\aversion\x18\x03 \x01(\tR\aversion\"\x1c\n" + "\x1aCreateQueryCheckpointOrder\"A\n" + "\x1aDeleteQueryCheckpointOrder\x12#\n" + "\rcheckpoint_id\x18\x01 \x01(\x06R\fcheckpointId\"\x90\x01\n" + @@ -6602,7 +6543,7 @@ func file_raft_cmd_proto_rawDescGZIP() []byte { } var file_raft_cmd_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_raft_cmd_proto_msgTypes = make([]protoimpl.MessageInfo, 96) +var file_raft_cmd_proto_msgTypes = make([]protoimpl.MessageInfo, 95) var file_raft_cmd_proto_goTypes = []any{ (BackupKind)(0), // 0: raft.BackupKind (BackupJobStatus)(0), // 1: raft.BackupJobStatus @@ -6626,274 +6567,272 @@ var file_raft_cmd_proto_goTypes = []any{ (*SetChapterScheduleOrder)(nil), // 19: raft.SetChapterScheduleOrder (*DeleteChapterScheduleOrder)(nil), // 20: raft.DeleteChapterScheduleOrder (*SaveNumscriptOrder)(nil), // 21: raft.SaveNumscriptOrder - (*DeleteNumscriptOrder)(nil), // 22: raft.DeleteNumscriptOrder - (*CreateQueryCheckpointOrder)(nil), // 23: raft.CreateQueryCheckpointOrder - (*DeleteQueryCheckpointOrder)(nil), // 24: raft.DeleteQueryCheckpointOrder - (*QueryCheckpointState)(nil), // 25: raft.QueryCheckpointState - (*SetQueryCheckpointScheduleOrder)(nil), // 26: raft.SetQueryCheckpointScheduleOrder - (*DeleteQueryCheckpointScheduleOrder)(nil), // 27: raft.DeleteQueryCheckpointScheduleOrder - (*CreateLedgerOrder)(nil), // 28: raft.CreateLedgerOrder - (*MirrorIngestOrder)(nil), // 29: raft.MirrorIngestOrder - (*MirrorLogEntry)(nil), // 30: raft.MirrorLogEntry - (*MirrorFillGap)(nil), // 31: raft.MirrorFillGap - (*MirrorCreatedTransaction)(nil), // 32: raft.MirrorCreatedTransaction - (*MirrorSavedMetadata)(nil), // 33: raft.MirrorSavedMetadata - (*MirrorRevertedTransaction)(nil), // 34: raft.MirrorRevertedTransaction - (*MirrorDeletedMetadata)(nil), // 35: raft.MirrorDeletedMetadata - (*PromoteLedgerOrder)(nil), // 36: raft.PromoteLedgerOrder - (*DeleteLedgerOrder)(nil), // 37: raft.DeleteLedgerOrder - (*LedgerApplyOrder)(nil), // 38: raft.LedgerApplyOrder - (*CreateIndexOrder)(nil), // 39: raft.CreateIndexOrder - (*DropIndexOrder)(nil), // 40: raft.DropIndexOrder - (*AddAccountTypeOrder)(nil), // 41: raft.AddAccountTypeOrder - (*RemoveAccountTypeOrder)(nil), // 42: raft.RemoveAccountTypeOrder - (*UpdateDefaultEnforcementModeOrder)(nil), // 43: raft.UpdateDefaultEnforcementModeOrder - (*SetMetadataFieldTypeOrder)(nil), // 44: raft.SetMetadataFieldTypeOrder - (*RemoveMetadataFieldTypeOrder)(nil), // 45: raft.RemoveMetadataFieldTypeOrder - (*CreateTransactionOrder)(nil), // 46: raft.CreateTransactionOrder - (*NumscriptReference)(nil), // 47: raft.NumscriptReference - (*SaveMetadataOrder)(nil), // 48: raft.SaveMetadataOrder - (*RevertTransactionOrder)(nil), // 49: raft.RevertTransactionOrder - (*DeleteMetadataOrder)(nil), // 50: raft.DeleteMetadataOrder - (*SaveLedgerMetadataOrder)(nil), // 51: raft.SaveLedgerMetadataOrder - (*DeleteLedgerMetadataOrder)(nil), // 52: raft.DeleteLedgerMetadataOrder - (*Proposal)(nil), // 53: raft.Proposal - (*TechnicalUpdate)(nil), // 54: raft.TechnicalUpdate - (*BackupDestination)(nil), // 55: raft.BackupDestination - (*S3BackupTarget)(nil), // 56: raft.S3BackupTarget - (*AzureBackupTarget)(nil), // 57: raft.AzureBackupTarget - (*BackupJob)(nil), // 58: raft.BackupJob - (*BackupOrder)(nil), // 59: raft.BackupOrder - (*IncrementalBackupOrder)(nil), // 60: raft.IncrementalBackupOrder - (*BackupOrderStart)(nil), // 61: raft.BackupOrderStart - (*BackupOrderComplete)(nil), // 62: raft.BackupOrderComplete - (*BackupOrderFail)(nil), // 63: raft.BackupOrderFail - (*IdempotencyEviction)(nil), // 64: raft.IdempotencyEviction - (*MirrorSyncUpdate)(nil), // 65: raft.MirrorSyncUpdate - (*EventsSinkUpdate)(nil), // 66: raft.EventsSinkUpdate - (*CreatedLogOrReference)(nil), // 67: raft.CreatedLogOrReference - (*LedgerBoundaries)(nil), // 68: raft.LedgerBoundaries - (*VolumePair)(nil), // 69: raft.VolumePair - (*ExecutionPlan)(nil), // 70: raft.ExecutionPlan - (*AttributeCoverage)(nil), // 71: raft.AttributeCoverage - (*AttributeValue)(nil), // 72: raft.AttributeValue - (*ReloadIdempotencyKey)(nil), // 73: raft.ReloadIdempotencyKey - (*CacheGenerationMeta)(nil), // 74: raft.CacheGenerationMeta - (*CacheSnapshotMeta)(nil), // 75: raft.CacheSnapshotMeta - (*PeerAddress)(nil), // 76: raft.PeerAddress - (*RemovedMemberEntry)(nil), // 77: raft.RemovedMemberEntry - (*GenerationSnapshot)(nil), // 78: raft.GenerationSnapshot - (*VolumeAttributeSnapshotEntry)(nil), // 79: raft.VolumeAttributeSnapshotEntry - (*MetadataAttributeEntry)(nil), // 80: raft.MetadataAttributeEntry - (*LedgerAttributeEntry)(nil), // 81: raft.LedgerAttributeEntry - (*BoundaryAttributeEntry)(nil), // 82: raft.BoundaryAttributeEntry - (*TransactionReferenceAttributeEntry)(nil), // 83: raft.TransactionReferenceAttributeEntry - (*TransactionStateAttributeEntry)(nil), // 84: raft.TransactionStateAttributeEntry - (*IdempotencyKeyAttributeEntry)(nil), // 85: raft.IdempotencyKeyAttributeEntry - (*AttributeID)(nil), // 86: raft.AttributeID - nil, // 87: raft.CreateLedgerOrder.AccountTypesEntry - nil, // 88: raft.MirrorCreatedTransaction.MetadataEntry - nil, // 89: raft.MirrorCreatedTransaction.AccountMetadataEntry - nil, // 90: raft.MirrorSavedMetadata.MetadataEntry - nil, // 91: raft.MirrorRevertedTransaction.MetadataEntry - nil, // 92: raft.CreateTransactionOrder.MetadataEntry - nil, // 93: raft.CreateTransactionOrder.AccountMetadataEntry - nil, // 94: raft.NumscriptReference.VarsEntry - nil, // 95: raft.SaveMetadataOrder.MetadataEntry - nil, // 96: raft.RevertTransactionOrder.MetadataEntry - nil, // 97: raft.SaveLedgerMetadataOrder.MetadataEntry - (*commonpb.PreparedQuery)(nil), // 98: common.PreparedQuery - (*commonpb.QueryFilter)(nil), // 99: common.QueryFilter - (*commonpb.SinkConfig)(nil), // 100: common.SinkConfig - (*commonpb.Timestamp)(nil), // 101: common.Timestamp - (*commonpb.SetMetadataFieldTypeCommand)(nil), // 102: common.SetMetadataFieldTypeCommand - (commonpb.LedgerMode)(0), // 103: common.LedgerMode - (*commonpb.MirrorSourceConfig)(nil), // 104: common.MirrorSourceConfig - (commonpb.ChartEnforcementMode)(0), // 105: common.ChartEnforcementMode - (*commonpb.Posting)(nil), // 106: common.Posting - (*commonpb.Target)(nil), // 107: common.Target - (commonpb.ErrorReason)(0), // 108: common.ErrorReason - (*commonpb.IndexID)(nil), // 109: common.IndexID - (*commonpb.AccountType)(nil), // 110: common.AccountType - (commonpb.TargetType)(0), // 111: common.TargetType - (commonpb.MetadataType)(0), // 112: common.MetadataType - (*commonpb.Script)(nil), // 113: common.Script - (*commonpb.CallerSnapshot)(nil), // 114: common.CallerSnapshot - (*commonpb.Idempotency)(nil), // 115: common.Idempotency - (*signaturepb.SignedApplyBatch)(nil), // 116: signature.SignedApplyBatch - (*commonpb.ClusterConfig)(nil), // 117: common.ClusterConfig - (*commonpb.MirrorSyncError)(nil), // 118: common.MirrorSyncError - (*commonpb.SinkError)(nil), // 119: common.SinkError - (*commonpb.Log)(nil), // 120: common.Log - (*commonpb.Uint256)(nil), // 121: common.Uint256 - (*commonpb.IdempotencyKeyValue)(nil), // 122: common.IdempotencyKeyValue - (*commonpb.MetadataValue)(nil), // 123: common.MetadataValue - (*commonpb.LedgerInfo)(nil), // 124: common.LedgerInfo - (*commonpb.TransactionReferenceValue)(nil), // 125: common.TransactionReferenceValue - (*commonpb.TransactionState)(nil), // 126: common.TransactionState - (*commonpb.MetadataMap)(nil), // 127: common.MetadataMap + (*CreateQueryCheckpointOrder)(nil), // 22: raft.CreateQueryCheckpointOrder + (*DeleteQueryCheckpointOrder)(nil), // 23: raft.DeleteQueryCheckpointOrder + (*QueryCheckpointState)(nil), // 24: raft.QueryCheckpointState + (*SetQueryCheckpointScheduleOrder)(nil), // 25: raft.SetQueryCheckpointScheduleOrder + (*DeleteQueryCheckpointScheduleOrder)(nil), // 26: raft.DeleteQueryCheckpointScheduleOrder + (*CreateLedgerOrder)(nil), // 27: raft.CreateLedgerOrder + (*MirrorIngestOrder)(nil), // 28: raft.MirrorIngestOrder + (*MirrorLogEntry)(nil), // 29: raft.MirrorLogEntry + (*MirrorFillGap)(nil), // 30: raft.MirrorFillGap + (*MirrorCreatedTransaction)(nil), // 31: raft.MirrorCreatedTransaction + (*MirrorSavedMetadata)(nil), // 32: raft.MirrorSavedMetadata + (*MirrorRevertedTransaction)(nil), // 33: raft.MirrorRevertedTransaction + (*MirrorDeletedMetadata)(nil), // 34: raft.MirrorDeletedMetadata + (*PromoteLedgerOrder)(nil), // 35: raft.PromoteLedgerOrder + (*DeleteLedgerOrder)(nil), // 36: raft.DeleteLedgerOrder + (*LedgerApplyOrder)(nil), // 37: raft.LedgerApplyOrder + (*CreateIndexOrder)(nil), // 38: raft.CreateIndexOrder + (*DropIndexOrder)(nil), // 39: raft.DropIndexOrder + (*AddAccountTypeOrder)(nil), // 40: raft.AddAccountTypeOrder + (*RemoveAccountTypeOrder)(nil), // 41: raft.RemoveAccountTypeOrder + (*UpdateDefaultEnforcementModeOrder)(nil), // 42: raft.UpdateDefaultEnforcementModeOrder + (*SetMetadataFieldTypeOrder)(nil), // 43: raft.SetMetadataFieldTypeOrder + (*RemoveMetadataFieldTypeOrder)(nil), // 44: raft.RemoveMetadataFieldTypeOrder + (*CreateTransactionOrder)(nil), // 45: raft.CreateTransactionOrder + (*NumscriptReference)(nil), // 46: raft.NumscriptReference + (*SaveMetadataOrder)(nil), // 47: raft.SaveMetadataOrder + (*RevertTransactionOrder)(nil), // 48: raft.RevertTransactionOrder + (*DeleteMetadataOrder)(nil), // 49: raft.DeleteMetadataOrder + (*SaveLedgerMetadataOrder)(nil), // 50: raft.SaveLedgerMetadataOrder + (*DeleteLedgerMetadataOrder)(nil), // 51: raft.DeleteLedgerMetadataOrder + (*Proposal)(nil), // 52: raft.Proposal + (*TechnicalUpdate)(nil), // 53: raft.TechnicalUpdate + (*BackupDestination)(nil), // 54: raft.BackupDestination + (*S3BackupTarget)(nil), // 55: raft.S3BackupTarget + (*AzureBackupTarget)(nil), // 56: raft.AzureBackupTarget + (*BackupJob)(nil), // 57: raft.BackupJob + (*BackupOrder)(nil), // 58: raft.BackupOrder + (*IncrementalBackupOrder)(nil), // 59: raft.IncrementalBackupOrder + (*BackupOrderStart)(nil), // 60: raft.BackupOrderStart + (*BackupOrderComplete)(nil), // 61: raft.BackupOrderComplete + (*BackupOrderFail)(nil), // 62: raft.BackupOrderFail + (*IdempotencyEviction)(nil), // 63: raft.IdempotencyEviction + (*MirrorSyncUpdate)(nil), // 64: raft.MirrorSyncUpdate + (*EventsSinkUpdate)(nil), // 65: raft.EventsSinkUpdate + (*CreatedLogOrReference)(nil), // 66: raft.CreatedLogOrReference + (*LedgerBoundaries)(nil), // 67: raft.LedgerBoundaries + (*VolumePair)(nil), // 68: raft.VolumePair + (*ExecutionPlan)(nil), // 69: raft.ExecutionPlan + (*AttributeCoverage)(nil), // 70: raft.AttributeCoverage + (*AttributeValue)(nil), // 71: raft.AttributeValue + (*ReloadIdempotencyKey)(nil), // 72: raft.ReloadIdempotencyKey + (*CacheGenerationMeta)(nil), // 73: raft.CacheGenerationMeta + (*CacheSnapshotMeta)(nil), // 74: raft.CacheSnapshotMeta + (*PeerAddress)(nil), // 75: raft.PeerAddress + (*RemovedMemberEntry)(nil), // 76: raft.RemovedMemberEntry + (*GenerationSnapshot)(nil), // 77: raft.GenerationSnapshot + (*VolumeAttributeSnapshotEntry)(nil), // 78: raft.VolumeAttributeSnapshotEntry + (*MetadataAttributeEntry)(nil), // 79: raft.MetadataAttributeEntry + (*LedgerAttributeEntry)(nil), // 80: raft.LedgerAttributeEntry + (*BoundaryAttributeEntry)(nil), // 81: raft.BoundaryAttributeEntry + (*TransactionReferenceAttributeEntry)(nil), // 82: raft.TransactionReferenceAttributeEntry + (*TransactionStateAttributeEntry)(nil), // 83: raft.TransactionStateAttributeEntry + (*IdempotencyKeyAttributeEntry)(nil), // 84: raft.IdempotencyKeyAttributeEntry + (*AttributeID)(nil), // 85: raft.AttributeID + nil, // 86: raft.CreateLedgerOrder.AccountTypesEntry + nil, // 87: raft.MirrorCreatedTransaction.MetadataEntry + nil, // 88: raft.MirrorCreatedTransaction.AccountMetadataEntry + nil, // 89: raft.MirrorSavedMetadata.MetadataEntry + nil, // 90: raft.MirrorRevertedTransaction.MetadataEntry + nil, // 91: raft.CreateTransactionOrder.MetadataEntry + nil, // 92: raft.CreateTransactionOrder.AccountMetadataEntry + nil, // 93: raft.NumscriptReference.VarsEntry + nil, // 94: raft.SaveMetadataOrder.MetadataEntry + nil, // 95: raft.RevertTransactionOrder.MetadataEntry + nil, // 96: raft.SaveLedgerMetadataOrder.MetadataEntry + (*commonpb.PreparedQuery)(nil), // 97: common.PreparedQuery + (*commonpb.QueryFilter)(nil), // 98: common.QueryFilter + (*commonpb.SinkConfig)(nil), // 99: common.SinkConfig + (*commonpb.Timestamp)(nil), // 100: common.Timestamp + (*commonpb.SetMetadataFieldTypeCommand)(nil), // 101: common.SetMetadataFieldTypeCommand + (commonpb.LedgerMode)(0), // 102: common.LedgerMode + (*commonpb.MirrorSourceConfig)(nil), // 103: common.MirrorSourceConfig + (commonpb.ChartEnforcementMode)(0), // 104: common.ChartEnforcementMode + (*commonpb.Posting)(nil), // 105: common.Posting + (*commonpb.Target)(nil), // 106: common.Target + (commonpb.ErrorReason)(0), // 107: common.ErrorReason + (*commonpb.IndexID)(nil), // 108: common.IndexID + (*commonpb.AccountType)(nil), // 109: common.AccountType + (commonpb.TargetType)(0), // 110: common.TargetType + (commonpb.MetadataType)(0), // 111: common.MetadataType + (*commonpb.Script)(nil), // 112: common.Script + (*commonpb.CallerSnapshot)(nil), // 113: common.CallerSnapshot + (*commonpb.Idempotency)(nil), // 114: common.Idempotency + (*signaturepb.SignedApplyBatch)(nil), // 115: signature.SignedApplyBatch + (*commonpb.ClusterConfig)(nil), // 116: common.ClusterConfig + (*commonpb.MirrorSyncError)(nil), // 117: common.MirrorSyncError + (*commonpb.SinkError)(nil), // 118: common.SinkError + (*commonpb.Log)(nil), // 119: common.Log + (*commonpb.Uint256)(nil), // 120: common.Uint256 + (*commonpb.IdempotencyKeyValue)(nil), // 121: common.IdempotencyKeyValue + (*commonpb.MetadataValue)(nil), // 122: common.MetadataValue + (*commonpb.LedgerInfo)(nil), // 123: common.LedgerInfo + (*commonpb.TransactionReferenceValue)(nil), // 124: common.TransactionReferenceValue + (*commonpb.TransactionState)(nil), // 125: common.TransactionState + (*commonpb.MetadataMap)(nil), // 126: common.MetadataMap } var file_raft_cmd_proto_depIdxs = []int32{ 4, // 0: raft.Order.ledger_scoped:type_name -> raft.LedgerScopedOrder 5, // 1: raft.Order.system_scoped:type_name -> raft.SystemScopedOrder 3, // 2: raft.Order.technical:type_name -> raft.OrderTechnical - 38, // 3: raft.LedgerScopedOrder.apply:type_name -> raft.LedgerApplyOrder - 28, // 4: raft.LedgerScopedOrder.create_ledger:type_name -> raft.CreateLedgerOrder - 37, // 5: raft.LedgerScopedOrder.delete_ledger:type_name -> raft.DeleteLedgerOrder - 29, // 6: raft.LedgerScopedOrder.mirror_ingest:type_name -> raft.MirrorIngestOrder - 36, // 7: raft.LedgerScopedOrder.promote_ledger:type_name -> raft.PromoteLedgerOrder - 51, // 8: raft.LedgerScopedOrder.save_ledger_metadata:type_name -> raft.SaveLedgerMetadataOrder - 52, // 9: raft.LedgerScopedOrder.delete_ledger_metadata:type_name -> raft.DeleteLedgerMetadataOrder + 37, // 3: raft.LedgerScopedOrder.apply:type_name -> raft.LedgerApplyOrder + 27, // 4: raft.LedgerScopedOrder.create_ledger:type_name -> raft.CreateLedgerOrder + 36, // 5: raft.LedgerScopedOrder.delete_ledger:type_name -> raft.DeleteLedgerOrder + 28, // 6: raft.LedgerScopedOrder.mirror_ingest:type_name -> raft.MirrorIngestOrder + 35, // 7: raft.LedgerScopedOrder.promote_ledger:type_name -> raft.PromoteLedgerOrder + 50, // 8: raft.LedgerScopedOrder.save_ledger_metadata:type_name -> raft.SaveLedgerMetadataOrder + 51, // 9: raft.LedgerScopedOrder.delete_ledger_metadata:type_name -> raft.DeleteLedgerMetadataOrder 21, // 10: raft.LedgerScopedOrder.save_numscript:type_name -> raft.SaveNumscriptOrder - 22, // 11: raft.LedgerScopedOrder.delete_numscript:type_name -> raft.DeleteNumscriptOrder - 6, // 12: raft.LedgerScopedOrder.create_prepared_query:type_name -> raft.CreatePreparedQueryOrder - 7, // 13: raft.LedgerScopedOrder.update_prepared_query:type_name -> raft.UpdatePreparedQueryOrder - 8, // 14: raft.LedgerScopedOrder.delete_prepared_query:type_name -> raft.DeletePreparedQueryOrder - 11, // 15: raft.SystemScopedOrder.register_signing_key:type_name -> raft.RegisterSigningKeyOrder - 12, // 16: raft.SystemScopedOrder.revoke_signing_key:type_name -> raft.RevokeSigningKeyOrder - 13, // 17: raft.SystemScopedOrder.set_signing_config:type_name -> raft.SetSigningConfigOrder - 9, // 18: raft.SystemScopedOrder.add_events_sink:type_name -> raft.AddEventsSinkOrder - 10, // 19: raft.SystemScopedOrder.remove_events_sink:type_name -> raft.RemoveEventsSinkOrder - 14, // 20: raft.SystemScopedOrder.close_chapter:type_name -> raft.CloseChapterOrder - 15, // 21: raft.SystemScopedOrder.seal_chapter:type_name -> raft.SealChapterOrder - 16, // 22: raft.SystemScopedOrder.archive_chapter:type_name -> raft.ArchiveChapterOrder - 17, // 23: raft.SystemScopedOrder.confirm_archive_chapter:type_name -> raft.ConfirmArchiveChapterOrder - 18, // 24: raft.SystemScopedOrder.set_maintenance_mode:type_name -> raft.SetMaintenanceModeOrder - 19, // 25: raft.SystemScopedOrder.set_chapter_schedule:type_name -> raft.SetChapterScheduleOrder - 20, // 26: raft.SystemScopedOrder.delete_chapter_schedule:type_name -> raft.DeleteChapterScheduleOrder - 23, // 27: raft.SystemScopedOrder.create_query_checkpoint:type_name -> raft.CreateQueryCheckpointOrder - 24, // 28: raft.SystemScopedOrder.delete_query_checkpoint:type_name -> raft.DeleteQueryCheckpointOrder - 26, // 29: raft.SystemScopedOrder.set_query_checkpoint_schedule:type_name -> raft.SetQueryCheckpointScheduleOrder - 27, // 30: raft.SystemScopedOrder.delete_query_checkpoint_schedule:type_name -> raft.DeleteQueryCheckpointScheduleOrder - 98, // 31: raft.CreatePreparedQueryOrder.query:type_name -> common.PreparedQuery - 99, // 32: raft.UpdatePreparedQueryOrder.filter:type_name -> common.QueryFilter - 100, // 33: raft.AddEventsSinkOrder.config:type_name -> common.SinkConfig - 101, // 34: raft.QueryCheckpointState.created_at:type_name -> common.Timestamp - 102, // 35: raft.CreateLedgerOrder.initial_schema:type_name -> common.SetMetadataFieldTypeCommand - 103, // 36: raft.CreateLedgerOrder.mode:type_name -> common.LedgerMode - 104, // 37: raft.CreateLedgerOrder.mirror_source:type_name -> common.MirrorSourceConfig - 87, // 38: raft.CreateLedgerOrder.account_types:type_name -> raft.CreateLedgerOrder.AccountTypesEntry - 105, // 39: raft.CreateLedgerOrder.default_enforcement_mode:type_name -> common.ChartEnforcementMode - 30, // 40: raft.MirrorIngestOrder.entry:type_name -> raft.MirrorLogEntry - 32, // 41: raft.MirrorLogEntry.created_transaction:type_name -> raft.MirrorCreatedTransaction - 33, // 42: raft.MirrorLogEntry.saved_metadata:type_name -> raft.MirrorSavedMetadata - 34, // 43: raft.MirrorLogEntry.reverted_transaction:type_name -> raft.MirrorRevertedTransaction - 35, // 44: raft.MirrorLogEntry.deleted_metadata:type_name -> raft.MirrorDeletedMetadata - 31, // 45: raft.MirrorLogEntry.fill_gap:type_name -> raft.MirrorFillGap - 106, // 46: raft.MirrorCreatedTransaction.postings:type_name -> common.Posting - 88, // 47: raft.MirrorCreatedTransaction.metadata:type_name -> raft.MirrorCreatedTransaction.MetadataEntry - 101, // 48: raft.MirrorCreatedTransaction.timestamp:type_name -> common.Timestamp - 89, // 49: raft.MirrorCreatedTransaction.account_metadata:type_name -> raft.MirrorCreatedTransaction.AccountMetadataEntry - 107, // 50: raft.MirrorSavedMetadata.target:type_name -> common.Target - 90, // 51: raft.MirrorSavedMetadata.metadata:type_name -> raft.MirrorSavedMetadata.MetadataEntry - 106, // 52: raft.MirrorRevertedTransaction.reverse_postings:type_name -> common.Posting - 91, // 53: raft.MirrorRevertedTransaction.metadata:type_name -> raft.MirrorRevertedTransaction.MetadataEntry - 101, // 54: raft.MirrorRevertedTransaction.timestamp:type_name -> common.Timestamp - 107, // 55: raft.MirrorDeletedMetadata.target:type_name -> common.Target - 46, // 56: raft.LedgerApplyOrder.create_transaction:type_name -> raft.CreateTransactionOrder - 48, // 57: raft.LedgerApplyOrder.add_metadata:type_name -> raft.SaveMetadataOrder - 49, // 58: raft.LedgerApplyOrder.revert_transaction:type_name -> raft.RevertTransactionOrder - 50, // 59: raft.LedgerApplyOrder.delete_metadata:type_name -> raft.DeleteMetadataOrder - 44, // 60: raft.LedgerApplyOrder.set_metadata_field_type:type_name -> raft.SetMetadataFieldTypeOrder - 45, // 61: raft.LedgerApplyOrder.remove_metadata_field_type:type_name -> raft.RemoveMetadataFieldTypeOrder - 39, // 62: raft.LedgerApplyOrder.create_index:type_name -> raft.CreateIndexOrder - 40, // 63: raft.LedgerApplyOrder.drop_index:type_name -> raft.DropIndexOrder - 41, // 64: raft.LedgerApplyOrder.add_account_type:type_name -> raft.AddAccountTypeOrder - 42, // 65: raft.LedgerApplyOrder.remove_account_type:type_name -> raft.RemoveAccountTypeOrder - 43, // 66: raft.LedgerApplyOrder.update_default_enforcement_mode:type_name -> raft.UpdateDefaultEnforcementModeOrder - 108, // 67: raft.LedgerApplyOrder.skippable_reasons:type_name -> common.ErrorReason - 109, // 68: raft.CreateIndexOrder.id:type_name -> common.IndexID - 109, // 69: raft.DropIndexOrder.id:type_name -> common.IndexID - 110, // 70: raft.AddAccountTypeOrder.account_type:type_name -> common.AccountType - 105, // 71: raft.UpdateDefaultEnforcementModeOrder.enforcement_mode:type_name -> common.ChartEnforcementMode - 111, // 72: raft.SetMetadataFieldTypeOrder.target_type:type_name -> common.TargetType - 112, // 73: raft.SetMetadataFieldTypeOrder.type:type_name -> common.MetadataType - 111, // 74: raft.RemoveMetadataFieldTypeOrder.target_type:type_name -> common.TargetType - 106, // 75: raft.CreateTransactionOrder.postings:type_name -> common.Posting - 113, // 76: raft.CreateTransactionOrder.script:type_name -> common.Script - 101, // 77: raft.CreateTransactionOrder.timestamp:type_name -> common.Timestamp - 92, // 78: raft.CreateTransactionOrder.metadata:type_name -> raft.CreateTransactionOrder.MetadataEntry - 93, // 79: raft.CreateTransactionOrder.account_metadata:type_name -> raft.CreateTransactionOrder.AccountMetadataEntry - 47, // 80: raft.CreateTransactionOrder.numscript_reference:type_name -> raft.NumscriptReference - 94, // 81: raft.NumscriptReference.vars:type_name -> raft.NumscriptReference.VarsEntry - 107, // 82: raft.SaveMetadataOrder.target:type_name -> common.Target - 95, // 83: raft.SaveMetadataOrder.metadata:type_name -> raft.SaveMetadataOrder.MetadataEntry - 96, // 84: raft.RevertTransactionOrder.metadata:type_name -> raft.RevertTransactionOrder.MetadataEntry - 106, // 85: raft.RevertTransactionOrder.original_postings:type_name -> common.Posting - 107, // 86: raft.DeleteMetadataOrder.target:type_name -> common.Target - 97, // 87: raft.SaveLedgerMetadataOrder.metadata:type_name -> raft.SaveLedgerMetadataOrder.MetadataEntry - 2, // 88: raft.Proposal.orders:type_name -> raft.Order - 101, // 89: raft.Proposal.date:type_name -> common.Timestamp - 70, // 90: raft.Proposal.execution_plan:type_name -> raft.ExecutionPlan - 114, // 91: raft.Proposal.caller_snapshot:type_name -> common.CallerSnapshot - 115, // 92: raft.Proposal.idempotency:type_name -> common.Idempotency - 116, // 93: raft.Proposal.signature:type_name -> signature.SignedApplyBatch - 54, // 94: raft.Proposal.technical_updates:type_name -> raft.TechnicalUpdate - 65, // 95: raft.TechnicalUpdate.mirror_sync:type_name -> raft.MirrorSyncUpdate - 66, // 96: raft.TechnicalUpdate.events_sink:type_name -> raft.EventsSinkUpdate - 64, // 97: raft.TechnicalUpdate.idempotency_eviction:type_name -> raft.IdempotencyEviction - 117, // 98: raft.TechnicalUpdate.cluster_config:type_name -> common.ClusterConfig - 59, // 99: raft.TechnicalUpdate.backup_order:type_name -> raft.BackupOrder - 60, // 100: raft.TechnicalUpdate.incremental_backup_order:type_name -> raft.IncrementalBackupOrder - 56, // 101: raft.BackupDestination.s3:type_name -> raft.S3BackupTarget - 57, // 102: raft.BackupDestination.azure:type_name -> raft.AzureBackupTarget - 0, // 103: raft.BackupJob.kind:type_name -> raft.BackupKind - 1, // 104: raft.BackupJob.status:type_name -> raft.BackupJobStatus - 55, // 105: raft.BackupJob.destination:type_name -> raft.BackupDestination - 61, // 106: raft.BackupOrder.start:type_name -> raft.BackupOrderStart - 62, // 107: raft.BackupOrder.complete:type_name -> raft.BackupOrderComplete - 63, // 108: raft.BackupOrder.fail:type_name -> raft.BackupOrderFail - 61, // 109: raft.IncrementalBackupOrder.start:type_name -> raft.BackupOrderStart - 62, // 110: raft.IncrementalBackupOrder.complete:type_name -> raft.BackupOrderComplete - 63, // 111: raft.IncrementalBackupOrder.fail:type_name -> raft.BackupOrderFail - 55, // 112: raft.BackupOrderStart.destination:type_name -> raft.BackupDestination - 118, // 113: raft.MirrorSyncUpdate.error:type_name -> common.MirrorSyncError - 119, // 114: raft.EventsSinkUpdate.error:type_name -> common.SinkError - 120, // 115: raft.CreatedLogOrReference.created_log:type_name -> common.Log - 121, // 116: raft.VolumePair.input:type_name -> common.Uint256 - 121, // 117: raft.VolumePair.output:type_name -> common.Uint256 - 71, // 118: raft.ExecutionPlan.attributes:type_name -> raft.AttributeCoverage - 73, // 119: raft.ExecutionPlan.idempotency_keys:type_name -> raft.ReloadIdempotencyKey - 86, // 120: raft.AttributeCoverage.id:type_name -> raft.AttributeID - 72, // 121: raft.AttributeCoverage.value:type_name -> raft.AttributeValue - 122, // 122: raft.ReloadIdempotencyKey.value:type_name -> common.IdempotencyKeyValue - 79, // 123: raft.GenerationSnapshot.volumes:type_name -> raft.VolumeAttributeSnapshotEntry - 80, // 124: raft.GenerationSnapshot.metadata:type_name -> raft.MetadataAttributeEntry - 80, // 125: raft.GenerationSnapshot.ledger_metadata:type_name -> raft.MetadataAttributeEntry - 81, // 126: raft.GenerationSnapshot.ledgers:type_name -> raft.LedgerAttributeEntry - 82, // 127: raft.GenerationSnapshot.boundaries:type_name -> raft.BoundaryAttributeEntry - 83, // 128: raft.GenerationSnapshot.references:type_name -> raft.TransactionReferenceAttributeEntry - 84, // 129: raft.GenerationSnapshot.transactions:type_name -> raft.TransactionStateAttributeEntry - 86, // 130: raft.VolumeAttributeSnapshotEntry.id:type_name -> raft.AttributeID - 121, // 131: raft.VolumeAttributeSnapshotEntry.input:type_name -> common.Uint256 - 121, // 132: raft.VolumeAttributeSnapshotEntry.output:type_name -> common.Uint256 - 86, // 133: raft.MetadataAttributeEntry.id:type_name -> raft.AttributeID - 123, // 134: raft.MetadataAttributeEntry.value:type_name -> common.MetadataValue - 86, // 135: raft.LedgerAttributeEntry.id:type_name -> raft.AttributeID - 124, // 136: raft.LedgerAttributeEntry.info:type_name -> common.LedgerInfo - 86, // 137: raft.BoundaryAttributeEntry.id:type_name -> raft.AttributeID - 68, // 138: raft.BoundaryAttributeEntry.boundaries:type_name -> raft.LedgerBoundaries - 86, // 139: raft.TransactionReferenceAttributeEntry.id:type_name -> raft.AttributeID - 125, // 140: raft.TransactionReferenceAttributeEntry.value:type_name -> common.TransactionReferenceValue - 86, // 141: raft.TransactionStateAttributeEntry.id:type_name -> raft.AttributeID - 126, // 142: raft.TransactionStateAttributeEntry.state:type_name -> common.TransactionState - 86, // 143: raft.IdempotencyKeyAttributeEntry.id:type_name -> raft.AttributeID - 122, // 144: raft.IdempotencyKeyAttributeEntry.value:type_name -> common.IdempotencyKeyValue - 110, // 145: raft.CreateLedgerOrder.AccountTypesEntry.value:type_name -> common.AccountType - 123, // 146: raft.MirrorCreatedTransaction.MetadataEntry.value:type_name -> common.MetadataValue - 127, // 147: raft.MirrorCreatedTransaction.AccountMetadataEntry.value:type_name -> common.MetadataMap - 123, // 148: raft.MirrorSavedMetadata.MetadataEntry.value:type_name -> common.MetadataValue - 123, // 149: raft.MirrorRevertedTransaction.MetadataEntry.value:type_name -> common.MetadataValue - 123, // 150: raft.CreateTransactionOrder.MetadataEntry.value:type_name -> common.MetadataValue - 127, // 151: raft.CreateTransactionOrder.AccountMetadataEntry.value:type_name -> common.MetadataMap - 123, // 152: raft.SaveMetadataOrder.MetadataEntry.value:type_name -> common.MetadataValue - 123, // 153: raft.RevertTransactionOrder.MetadataEntry.value:type_name -> common.MetadataValue - 123, // 154: raft.SaveLedgerMetadataOrder.MetadataEntry.value:type_name -> common.MetadataValue - 155, // [155:155] is the sub-list for method output_type - 155, // [155:155] is the sub-list for method input_type - 155, // [155:155] is the sub-list for extension type_name - 155, // [155:155] is the sub-list for extension extendee - 0, // [0:155] is the sub-list for field type_name + 6, // 11: raft.LedgerScopedOrder.create_prepared_query:type_name -> raft.CreatePreparedQueryOrder + 7, // 12: raft.LedgerScopedOrder.update_prepared_query:type_name -> raft.UpdatePreparedQueryOrder + 8, // 13: raft.LedgerScopedOrder.delete_prepared_query:type_name -> raft.DeletePreparedQueryOrder + 11, // 14: raft.SystemScopedOrder.register_signing_key:type_name -> raft.RegisterSigningKeyOrder + 12, // 15: raft.SystemScopedOrder.revoke_signing_key:type_name -> raft.RevokeSigningKeyOrder + 13, // 16: raft.SystemScopedOrder.set_signing_config:type_name -> raft.SetSigningConfigOrder + 9, // 17: raft.SystemScopedOrder.add_events_sink:type_name -> raft.AddEventsSinkOrder + 10, // 18: raft.SystemScopedOrder.remove_events_sink:type_name -> raft.RemoveEventsSinkOrder + 14, // 19: raft.SystemScopedOrder.close_chapter:type_name -> raft.CloseChapterOrder + 15, // 20: raft.SystemScopedOrder.seal_chapter:type_name -> raft.SealChapterOrder + 16, // 21: raft.SystemScopedOrder.archive_chapter:type_name -> raft.ArchiveChapterOrder + 17, // 22: raft.SystemScopedOrder.confirm_archive_chapter:type_name -> raft.ConfirmArchiveChapterOrder + 18, // 23: raft.SystemScopedOrder.set_maintenance_mode:type_name -> raft.SetMaintenanceModeOrder + 19, // 24: raft.SystemScopedOrder.set_chapter_schedule:type_name -> raft.SetChapterScheduleOrder + 20, // 25: raft.SystemScopedOrder.delete_chapter_schedule:type_name -> raft.DeleteChapterScheduleOrder + 22, // 26: raft.SystemScopedOrder.create_query_checkpoint:type_name -> raft.CreateQueryCheckpointOrder + 23, // 27: raft.SystemScopedOrder.delete_query_checkpoint:type_name -> raft.DeleteQueryCheckpointOrder + 25, // 28: raft.SystemScopedOrder.set_query_checkpoint_schedule:type_name -> raft.SetQueryCheckpointScheduleOrder + 26, // 29: raft.SystemScopedOrder.delete_query_checkpoint_schedule:type_name -> raft.DeleteQueryCheckpointScheduleOrder + 97, // 30: raft.CreatePreparedQueryOrder.query:type_name -> common.PreparedQuery + 98, // 31: raft.UpdatePreparedQueryOrder.filter:type_name -> common.QueryFilter + 99, // 32: raft.AddEventsSinkOrder.config:type_name -> common.SinkConfig + 100, // 33: raft.QueryCheckpointState.created_at:type_name -> common.Timestamp + 101, // 34: raft.CreateLedgerOrder.initial_schema:type_name -> common.SetMetadataFieldTypeCommand + 102, // 35: raft.CreateLedgerOrder.mode:type_name -> common.LedgerMode + 103, // 36: raft.CreateLedgerOrder.mirror_source:type_name -> common.MirrorSourceConfig + 86, // 37: raft.CreateLedgerOrder.account_types:type_name -> raft.CreateLedgerOrder.AccountTypesEntry + 104, // 38: raft.CreateLedgerOrder.default_enforcement_mode:type_name -> common.ChartEnforcementMode + 29, // 39: raft.MirrorIngestOrder.entry:type_name -> raft.MirrorLogEntry + 31, // 40: raft.MirrorLogEntry.created_transaction:type_name -> raft.MirrorCreatedTransaction + 32, // 41: raft.MirrorLogEntry.saved_metadata:type_name -> raft.MirrorSavedMetadata + 33, // 42: raft.MirrorLogEntry.reverted_transaction:type_name -> raft.MirrorRevertedTransaction + 34, // 43: raft.MirrorLogEntry.deleted_metadata:type_name -> raft.MirrorDeletedMetadata + 30, // 44: raft.MirrorLogEntry.fill_gap:type_name -> raft.MirrorFillGap + 105, // 45: raft.MirrorCreatedTransaction.postings:type_name -> common.Posting + 87, // 46: raft.MirrorCreatedTransaction.metadata:type_name -> raft.MirrorCreatedTransaction.MetadataEntry + 100, // 47: raft.MirrorCreatedTransaction.timestamp:type_name -> common.Timestamp + 88, // 48: raft.MirrorCreatedTransaction.account_metadata:type_name -> raft.MirrorCreatedTransaction.AccountMetadataEntry + 106, // 49: raft.MirrorSavedMetadata.target:type_name -> common.Target + 89, // 50: raft.MirrorSavedMetadata.metadata:type_name -> raft.MirrorSavedMetadata.MetadataEntry + 105, // 51: raft.MirrorRevertedTransaction.reverse_postings:type_name -> common.Posting + 90, // 52: raft.MirrorRevertedTransaction.metadata:type_name -> raft.MirrorRevertedTransaction.MetadataEntry + 100, // 53: raft.MirrorRevertedTransaction.timestamp:type_name -> common.Timestamp + 106, // 54: raft.MirrorDeletedMetadata.target:type_name -> common.Target + 45, // 55: raft.LedgerApplyOrder.create_transaction:type_name -> raft.CreateTransactionOrder + 47, // 56: raft.LedgerApplyOrder.add_metadata:type_name -> raft.SaveMetadataOrder + 48, // 57: raft.LedgerApplyOrder.revert_transaction:type_name -> raft.RevertTransactionOrder + 49, // 58: raft.LedgerApplyOrder.delete_metadata:type_name -> raft.DeleteMetadataOrder + 43, // 59: raft.LedgerApplyOrder.set_metadata_field_type:type_name -> raft.SetMetadataFieldTypeOrder + 44, // 60: raft.LedgerApplyOrder.remove_metadata_field_type:type_name -> raft.RemoveMetadataFieldTypeOrder + 38, // 61: raft.LedgerApplyOrder.create_index:type_name -> raft.CreateIndexOrder + 39, // 62: raft.LedgerApplyOrder.drop_index:type_name -> raft.DropIndexOrder + 40, // 63: raft.LedgerApplyOrder.add_account_type:type_name -> raft.AddAccountTypeOrder + 41, // 64: raft.LedgerApplyOrder.remove_account_type:type_name -> raft.RemoveAccountTypeOrder + 42, // 65: raft.LedgerApplyOrder.update_default_enforcement_mode:type_name -> raft.UpdateDefaultEnforcementModeOrder + 107, // 66: raft.LedgerApplyOrder.skippable_reasons:type_name -> common.ErrorReason + 108, // 67: raft.CreateIndexOrder.id:type_name -> common.IndexID + 108, // 68: raft.DropIndexOrder.id:type_name -> common.IndexID + 109, // 69: raft.AddAccountTypeOrder.account_type:type_name -> common.AccountType + 104, // 70: raft.UpdateDefaultEnforcementModeOrder.enforcement_mode:type_name -> common.ChartEnforcementMode + 110, // 71: raft.SetMetadataFieldTypeOrder.target_type:type_name -> common.TargetType + 111, // 72: raft.SetMetadataFieldTypeOrder.type:type_name -> common.MetadataType + 110, // 73: raft.RemoveMetadataFieldTypeOrder.target_type:type_name -> common.TargetType + 105, // 74: raft.CreateTransactionOrder.postings:type_name -> common.Posting + 112, // 75: raft.CreateTransactionOrder.script:type_name -> common.Script + 100, // 76: raft.CreateTransactionOrder.timestamp:type_name -> common.Timestamp + 91, // 77: raft.CreateTransactionOrder.metadata:type_name -> raft.CreateTransactionOrder.MetadataEntry + 92, // 78: raft.CreateTransactionOrder.account_metadata:type_name -> raft.CreateTransactionOrder.AccountMetadataEntry + 46, // 79: raft.CreateTransactionOrder.numscript_reference:type_name -> raft.NumscriptReference + 93, // 80: raft.NumscriptReference.vars:type_name -> raft.NumscriptReference.VarsEntry + 106, // 81: raft.SaveMetadataOrder.target:type_name -> common.Target + 94, // 82: raft.SaveMetadataOrder.metadata:type_name -> raft.SaveMetadataOrder.MetadataEntry + 95, // 83: raft.RevertTransactionOrder.metadata:type_name -> raft.RevertTransactionOrder.MetadataEntry + 105, // 84: raft.RevertTransactionOrder.original_postings:type_name -> common.Posting + 106, // 85: raft.DeleteMetadataOrder.target:type_name -> common.Target + 96, // 86: raft.SaveLedgerMetadataOrder.metadata:type_name -> raft.SaveLedgerMetadataOrder.MetadataEntry + 2, // 87: raft.Proposal.orders:type_name -> raft.Order + 100, // 88: raft.Proposal.date:type_name -> common.Timestamp + 69, // 89: raft.Proposal.execution_plan:type_name -> raft.ExecutionPlan + 113, // 90: raft.Proposal.caller_snapshot:type_name -> common.CallerSnapshot + 114, // 91: raft.Proposal.idempotency:type_name -> common.Idempotency + 115, // 92: raft.Proposal.signature:type_name -> signature.SignedApplyBatch + 53, // 93: raft.Proposal.technical_updates:type_name -> raft.TechnicalUpdate + 64, // 94: raft.TechnicalUpdate.mirror_sync:type_name -> raft.MirrorSyncUpdate + 65, // 95: raft.TechnicalUpdate.events_sink:type_name -> raft.EventsSinkUpdate + 63, // 96: raft.TechnicalUpdate.idempotency_eviction:type_name -> raft.IdempotencyEviction + 116, // 97: raft.TechnicalUpdate.cluster_config:type_name -> common.ClusterConfig + 58, // 98: raft.TechnicalUpdate.backup_order:type_name -> raft.BackupOrder + 59, // 99: raft.TechnicalUpdate.incremental_backup_order:type_name -> raft.IncrementalBackupOrder + 55, // 100: raft.BackupDestination.s3:type_name -> raft.S3BackupTarget + 56, // 101: raft.BackupDestination.azure:type_name -> raft.AzureBackupTarget + 0, // 102: raft.BackupJob.kind:type_name -> raft.BackupKind + 1, // 103: raft.BackupJob.status:type_name -> raft.BackupJobStatus + 54, // 104: raft.BackupJob.destination:type_name -> raft.BackupDestination + 60, // 105: raft.BackupOrder.start:type_name -> raft.BackupOrderStart + 61, // 106: raft.BackupOrder.complete:type_name -> raft.BackupOrderComplete + 62, // 107: raft.BackupOrder.fail:type_name -> raft.BackupOrderFail + 60, // 108: raft.IncrementalBackupOrder.start:type_name -> raft.BackupOrderStart + 61, // 109: raft.IncrementalBackupOrder.complete:type_name -> raft.BackupOrderComplete + 62, // 110: raft.IncrementalBackupOrder.fail:type_name -> raft.BackupOrderFail + 54, // 111: raft.BackupOrderStart.destination:type_name -> raft.BackupDestination + 117, // 112: raft.MirrorSyncUpdate.error:type_name -> common.MirrorSyncError + 118, // 113: raft.EventsSinkUpdate.error:type_name -> common.SinkError + 119, // 114: raft.CreatedLogOrReference.created_log:type_name -> common.Log + 120, // 115: raft.VolumePair.input:type_name -> common.Uint256 + 120, // 116: raft.VolumePair.output:type_name -> common.Uint256 + 70, // 117: raft.ExecutionPlan.attributes:type_name -> raft.AttributeCoverage + 72, // 118: raft.ExecutionPlan.idempotency_keys:type_name -> raft.ReloadIdempotencyKey + 85, // 119: raft.AttributeCoverage.id:type_name -> raft.AttributeID + 71, // 120: raft.AttributeCoverage.value:type_name -> raft.AttributeValue + 121, // 121: raft.ReloadIdempotencyKey.value:type_name -> common.IdempotencyKeyValue + 78, // 122: raft.GenerationSnapshot.volumes:type_name -> raft.VolumeAttributeSnapshotEntry + 79, // 123: raft.GenerationSnapshot.metadata:type_name -> raft.MetadataAttributeEntry + 79, // 124: raft.GenerationSnapshot.ledger_metadata:type_name -> raft.MetadataAttributeEntry + 80, // 125: raft.GenerationSnapshot.ledgers:type_name -> raft.LedgerAttributeEntry + 81, // 126: raft.GenerationSnapshot.boundaries:type_name -> raft.BoundaryAttributeEntry + 82, // 127: raft.GenerationSnapshot.references:type_name -> raft.TransactionReferenceAttributeEntry + 83, // 128: raft.GenerationSnapshot.transactions:type_name -> raft.TransactionStateAttributeEntry + 85, // 129: raft.VolumeAttributeSnapshotEntry.id:type_name -> raft.AttributeID + 120, // 130: raft.VolumeAttributeSnapshotEntry.input:type_name -> common.Uint256 + 120, // 131: raft.VolumeAttributeSnapshotEntry.output:type_name -> common.Uint256 + 85, // 132: raft.MetadataAttributeEntry.id:type_name -> raft.AttributeID + 122, // 133: raft.MetadataAttributeEntry.value:type_name -> common.MetadataValue + 85, // 134: raft.LedgerAttributeEntry.id:type_name -> raft.AttributeID + 123, // 135: raft.LedgerAttributeEntry.info:type_name -> common.LedgerInfo + 85, // 136: raft.BoundaryAttributeEntry.id:type_name -> raft.AttributeID + 67, // 137: raft.BoundaryAttributeEntry.boundaries:type_name -> raft.LedgerBoundaries + 85, // 138: raft.TransactionReferenceAttributeEntry.id:type_name -> raft.AttributeID + 124, // 139: raft.TransactionReferenceAttributeEntry.value:type_name -> common.TransactionReferenceValue + 85, // 140: raft.TransactionStateAttributeEntry.id:type_name -> raft.AttributeID + 125, // 141: raft.TransactionStateAttributeEntry.state:type_name -> common.TransactionState + 85, // 142: raft.IdempotencyKeyAttributeEntry.id:type_name -> raft.AttributeID + 121, // 143: raft.IdempotencyKeyAttributeEntry.value:type_name -> common.IdempotencyKeyValue + 109, // 144: raft.CreateLedgerOrder.AccountTypesEntry.value:type_name -> common.AccountType + 122, // 145: raft.MirrorCreatedTransaction.MetadataEntry.value:type_name -> common.MetadataValue + 126, // 146: raft.MirrorCreatedTransaction.AccountMetadataEntry.value:type_name -> common.MetadataMap + 122, // 147: raft.MirrorSavedMetadata.MetadataEntry.value:type_name -> common.MetadataValue + 122, // 148: raft.MirrorRevertedTransaction.MetadataEntry.value:type_name -> common.MetadataValue + 122, // 149: raft.CreateTransactionOrder.MetadataEntry.value:type_name -> common.MetadataValue + 126, // 150: raft.CreateTransactionOrder.AccountMetadataEntry.value:type_name -> common.MetadataMap + 122, // 151: raft.SaveMetadataOrder.MetadataEntry.value:type_name -> common.MetadataValue + 122, // 152: raft.RevertTransactionOrder.MetadataEntry.value:type_name -> common.MetadataValue + 122, // 153: raft.SaveLedgerMetadataOrder.MetadataEntry.value:type_name -> common.MetadataValue + 154, // [154:154] is the sub-list for method output_type + 154, // [154:154] is the sub-list for method input_type + 154, // [154:154] is the sub-list for extension type_name + 154, // [154:154] is the sub-list for extension extendee + 0, // [0:154] is the sub-list for field type_name } func init() { file_raft_cmd_proto_init() } @@ -6914,7 +6853,6 @@ func file_raft_cmd_proto_init() { (*LedgerScopedOrder_SaveLedgerMetadata)(nil), (*LedgerScopedOrder_DeleteLedgerMetadata)(nil), (*LedgerScopedOrder_SaveNumscript)(nil), - (*LedgerScopedOrder_DeleteNumscript)(nil), (*LedgerScopedOrder_CreatePreparedQuery)(nil), (*LedgerScopedOrder_UpdatePreparedQuery)(nil), (*LedgerScopedOrder_DeletePreparedQuery)(nil), @@ -6937,14 +6875,14 @@ func file_raft_cmd_proto_init() { (*SystemScopedOrder_SetQueryCheckpointSchedule)(nil), (*SystemScopedOrder_DeleteQueryCheckpointSchedule)(nil), } - file_raft_cmd_proto_msgTypes[28].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[27].OneofWrappers = []any{ (*MirrorLogEntry_CreatedTransaction)(nil), (*MirrorLogEntry_SavedMetadata)(nil), (*MirrorLogEntry_RevertedTransaction)(nil), (*MirrorLogEntry_DeletedMetadata)(nil), (*MirrorLogEntry_FillGap)(nil), } - file_raft_cmd_proto_msgTypes[36].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[35].OneofWrappers = []any{ (*LedgerApplyOrder_CreateTransaction)(nil), (*LedgerApplyOrder_AddMetadata)(nil), (*LedgerApplyOrder_RevertTransaction)(nil), @@ -6957,7 +6895,7 @@ func file_raft_cmd_proto_init() { (*LedgerApplyOrder_RemoveAccountType)(nil), (*LedgerApplyOrder_UpdateDefaultEnforcementMode)(nil), } - file_raft_cmd_proto_msgTypes[52].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[51].OneofWrappers = []any{ (*TechnicalUpdate_MirrorSync)(nil), (*TechnicalUpdate_EventsSink)(nil), (*TechnicalUpdate_IdempotencyEviction)(nil), @@ -6965,21 +6903,21 @@ func file_raft_cmd_proto_init() { (*TechnicalUpdate_BackupOrder)(nil), (*TechnicalUpdate_IncrementalBackupOrder)(nil), } - file_raft_cmd_proto_msgTypes[53].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[52].OneofWrappers = []any{ (*BackupDestination_S3)(nil), (*BackupDestination_Azure)(nil), } - file_raft_cmd_proto_msgTypes[57].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[56].OneofWrappers = []any{ (*BackupOrder_Start)(nil), (*BackupOrder_Complete)(nil), (*BackupOrder_Fail)(nil), } - file_raft_cmd_proto_msgTypes[58].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[57].OneofWrappers = []any{ (*IncrementalBackupOrder_Start)(nil), (*IncrementalBackupOrder_Complete)(nil), (*IncrementalBackupOrder_Fail)(nil), } - file_raft_cmd_proto_msgTypes[65].OneofWrappers = []any{ + file_raft_cmd_proto_msgTypes[64].OneofWrappers = []any{ (*CreatedLogOrReference_CreatedLog)(nil), (*CreatedLogOrReference_ReferenceSequence)(nil), } @@ -6989,7 +6927,7 @@ func file_raft_cmd_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_raft_cmd_proto_rawDesc), len(file_raft_cmd_proto_rawDesc)), NumEnums: 2, - NumMessages: 96, + NumMessages: 95, NumExtensions: 0, NumServices: 0, }, diff --git a/internal/proto/raftcmdpb/raft_cmd_dethash.pb.go b/internal/proto/raftcmdpb/raft_cmd_dethash.pb.go index 7144ce7866..817c050b52 100644 --- a/internal/proto/raftcmdpb/raft_cmd_dethash.pb.go +++ b/internal/proto/raftcmdpb/raft_cmd_dethash.pb.go @@ -171,14 +171,6 @@ func (m *LedgerScopedOrder) MarshalToSizedBufferDeterministicVT(dAtA []byte) (in i-- dAtA[i] = 0x4a } - case *LedgerScopedOrder_DeleteNumscript: - if v.DeleteNumscript != nil { - size, _ := v.DeleteNumscript.MarshalToSizedBufferVT(dAtA[:i]) - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x52 - } case *LedgerScopedOrder_CreatePreparedQuery: if v.CreatePreparedQuery != nil { size, _ := v.CreatePreparedQuery.MarshalToSizedBufferVT(dAtA[:i]) @@ -394,17 +386,6 @@ func (m *SaveNumscriptOrder) MarshalDeterministicVT(dAtA []byte) []byte { return append(dAtA, b...) } -func (m *DeleteNumscriptOrder) MarshalDeterministicVT(dAtA []byte) []byte { - if m == nil { - return dAtA - } - b, err := m.MarshalVT() - if err != nil { - panic("MarshalDeterministicVT: " + err.Error()) - } - return append(dAtA, b...) -} - func (m *CreateQueryCheckpointOrder) MarshalDeterministicVT(dAtA []byte) []byte { if m == nil { return dAtA diff --git a/internal/proto/raftcmdpb/raft_cmd_reader.pb.go b/internal/proto/raftcmdpb/raft_cmd_reader.pb.go index 4cfc80c588..a8e1d0fb07 100644 --- a/internal/proto/raftcmdpb/raft_cmd_reader.pb.go +++ b/internal/proto/raftcmdpb/raft_cmd_reader.pb.go @@ -1414,73 +1414,6 @@ func NewSaveNumscriptOrderListReader(s []*SaveNumscriptOrder) SaveNumscriptOrder return saveNumscriptOrderListReadonly(s) } -// DeleteNumscriptOrderReader provides read-only access to DeleteNumscriptOrder. -// Call Mutate() to obtain a mutable clone. -type DeleteNumscriptOrderReader interface { - GetName() string - Mutate() *DeleteNumscriptOrder -} - -type deleteNumscriptOrderReadonly DeleteNumscriptOrder - -func (r *deleteNumscriptOrderReadonly) GetName() string { - return (*DeleteNumscriptOrder)(r).GetName() -} - -func (r *deleteNumscriptOrderReadonly) Mutate() *DeleteNumscriptOrder { - return (*DeleteNumscriptOrder)(r).CloneVT() -} - -// AsReader returns a read-only view of this DeleteNumscriptOrder. -func (m *DeleteNumscriptOrder) AsReader() DeleteNumscriptOrderReader { - if m == nil { - return nil - } - return (*deleteNumscriptOrderReadonly)(m) -} - -// Mutate returns a mutable deep clone of this DeleteNumscriptOrder. -func (m *DeleteNumscriptOrder) Mutate() *DeleteNumscriptOrder { - return m.CloneVT() -} - -// DeleteNumscriptOrderListReader provides read-only iteration over []*DeleteNumscriptOrder. -type DeleteNumscriptOrderListReader interface { - Len() int - Get(i int) DeleteNumscriptOrderReader - Range(yield func(int, DeleteNumscriptOrderReader) bool) -} - -type deleteNumscriptOrderListReadonly []*DeleteNumscriptOrder - -func (l deleteNumscriptOrderListReadonly) Len() int { return len(l) } - -func (l deleteNumscriptOrderListReadonly) Get(i int) DeleteNumscriptOrderReader { - v := l[i] - if v == nil { - return nil - } - return v.AsReader() -} - -func (l deleteNumscriptOrderListReadonly) Range(yield func(int, DeleteNumscriptOrderReader) bool) { - for i, v := range l { - var r DeleteNumscriptOrderReader - if v != nil { - r = v.AsReader() - } - if !yield(i, r) { - return - } - } -} - -// NewDeleteNumscriptOrderListReader wraps s for read-only iteration. The returned -// view aliases the underlying slice; do not mutate s afterwards. -func NewDeleteNumscriptOrderListReader(s []*DeleteNumscriptOrder) DeleteNumscriptOrderListReader { - return deleteNumscriptOrderListReadonly(s) -} - // CreateQueryCheckpointOrderReader provides read-only access to CreateQueryCheckpointOrder. // Call Mutate() to obtain a mutable clone. type CreateQueryCheckpointOrderReader interface { diff --git a/internal/proto/raftcmdpb/raft_cmd_vtproto.pb.go b/internal/proto/raftcmdpb/raft_cmd_vtproto.pb.go index 4574736cba..97cb4973c6 100644 --- a/internal/proto/raftcmdpb/raft_cmd_vtproto.pb.go +++ b/internal/proto/raftcmdpb/raft_cmd_vtproto.pb.go @@ -182,15 +182,6 @@ func (m *LedgerScopedOrder_SaveNumscript) CloneVT() isLedgerScopedOrder_Payload return r } -func (m *LedgerScopedOrder_DeleteNumscript) CloneVT() isLedgerScopedOrder_Payload { - if m == nil { - return (*LedgerScopedOrder_DeleteNumscript)(nil) - } - r := new(LedgerScopedOrder_DeleteNumscript) - r.DeleteNumscript = m.DeleteNumscript.CloneVT() - return r -} - func (m *LedgerScopedOrder_CreatePreparedQuery) CloneVT() isLedgerScopedOrder_Payload { if m == nil { return (*LedgerScopedOrder_CreatePreparedQuery)(nil) @@ -673,23 +664,6 @@ func (m *SaveNumscriptOrder) CloneMessageVT() proto.Message { return m.CloneVT() } -func (m *DeleteNumscriptOrder) CloneVT() *DeleteNumscriptOrder { - if m == nil { - return (*DeleteNumscriptOrder)(nil) - } - r := new(DeleteNumscriptOrder) - r.Name = m.Name - if len(m.unknownFields) > 0 { - r.unknownFields = make([]byte, len(m.unknownFields)) - copy(r.unknownFields, m.unknownFields) - } - return r -} - -func (m *DeleteNumscriptOrder) CloneMessageVT() proto.Message { - return m.CloneVT() -} - func (m *CreateQueryCheckpointOrder) CloneVT() *CreateQueryCheckpointOrder { if m == nil { return (*CreateQueryCheckpointOrder)(nil) @@ -2740,31 +2714,6 @@ func (this *LedgerScopedOrder_SaveNumscript) EqualVT(thatIface isLedgerScopedOrd return true } -func (this *LedgerScopedOrder_DeleteNumscript) EqualVT(thatIface isLedgerScopedOrder_Payload) bool { - that, ok := thatIface.(*LedgerScopedOrder_DeleteNumscript) - if !ok { - return false - } - if this == that { - return true - } - if this == nil && that != nil || this != nil && that == nil { - return false - } - if p, q := this.DeleteNumscript, that.DeleteNumscript; p != q { - if p == nil { - p = &DeleteNumscriptOrder{} - } - if q == nil { - q = &DeleteNumscriptOrder{} - } - if !p.EqualVT(q) { - return false - } - } - return true -} - func (this *LedgerScopedOrder_CreatePreparedQuery) EqualVT(thatIface isLedgerScopedOrder_Payload) bool { that, ok := thatIface.(*LedgerScopedOrder_CreatePreparedQuery) if !ok { @@ -3590,25 +3539,6 @@ func (this *SaveNumscriptOrder) EqualMessageVT(thatMsg proto.Message) bool { } return this.EqualVT(that) } -func (this *DeleteNumscriptOrder) EqualVT(that *DeleteNumscriptOrder) bool { - if this == that { - return true - } else if this == nil || that == nil { - return false - } - if this.Name != that.Name { - return false - } - return string(this.unknownFields) == string(that.unknownFields) -} - -func (this *DeleteNumscriptOrder) EqualMessageVT(thatMsg proto.Message) bool { - that, ok := thatMsg.(*DeleteNumscriptOrder) - if !ok { - return false - } - return this.EqualVT(that) -} func (this *CreateQueryCheckpointOrder) EqualVT(that *CreateQueryCheckpointOrder) bool { if this == that { return true @@ -6780,25 +6710,6 @@ func (m *LedgerScopedOrder_SaveNumscript) MarshalToSizedBufferVT(dAtA []byte) (i } return len(dAtA) - i, nil } -func (m *LedgerScopedOrder_DeleteNumscript) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *LedgerScopedOrder_DeleteNumscript) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DeleteNumscript != nil { - size, err := m.DeleteNumscript.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x52 - } - return len(dAtA) - i, nil -} func (m *LedgerScopedOrder_CreatePreparedQuery) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) @@ -7901,46 +7812,6 @@ func (m *SaveNumscriptOrder) MarshalToSizedBufferVT(dAtA []byte) (int, error) { return len(dAtA) - i, nil } -func (m *DeleteNumscriptOrder) MarshalVT() (dAtA []byte, err error) { - if m == nil { - return nil, nil - } - size := m.SizeVT() - dAtA = make([]byte, size) - n, err := m.MarshalToSizedBufferVT(dAtA[:size]) - if err != nil { - return nil, err - } - return dAtA[:n], nil -} - -func (m *DeleteNumscriptOrder) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *DeleteNumscriptOrder) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - if m == nil { - return 0, nil - } - i := len(dAtA) - _ = i - var l int - _ = l - if m.unknownFields != nil { - i -= len(m.unknownFields) - copy(dAtA[i:], m.unknownFields) - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) - i-- - dAtA[i] = 0xa - } - return len(dAtA) - i, nil -} - func (m *CreateQueryCheckpointOrder) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil @@ -12584,18 +12455,6 @@ func (m *LedgerScopedOrder_SaveNumscript) SizeVT() (n int) { } return n } -func (m *LedgerScopedOrder_DeleteNumscript) SizeVT() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DeleteNumscript != nil { - l = m.DeleteNumscript.SizeVT() - n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) - } - return n -} func (m *LedgerScopedOrder_CreatePreparedQuery) SizeVT() (n int) { if m == nil { return 0 @@ -13079,20 +12938,6 @@ func (m *SaveNumscriptOrder) SizeVT() (n int) { return n } -func (m *DeleteNumscriptOrder) SizeVT() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - l = len(m.Name) - if l > 0 { - n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) - } - n += len(m.unknownFields) - return n -} - func (m *CreateQueryCheckpointOrder) SizeVT() (n int) { if m == nil { return 0 @@ -15574,47 +15419,6 @@ func (m *LedgerScopedOrder) UnmarshalVT(dAtA []byte) error { m.Payload = &LedgerScopedOrder_SaveNumscript{SaveNumscript: v} } iNdEx = postIndex - case 10: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeleteNumscript", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if oneof, ok := m.Payload.(*LedgerScopedOrder_DeleteNumscript); ok { - if err := oneof.DeleteNumscript.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - v := &DeleteNumscriptOrder{} - if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Payload = &LedgerScopedOrder_DeleteNumscript{DeleteNumscript: v} - } - iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CreatePreparedQuery", wireType) @@ -17903,89 +17707,6 @@ func (m *SaveNumscriptOrder) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *DeleteNumscriptOrder) UnmarshalVT(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: DeleteNumscriptOrder: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: DeleteNumscriptOrder: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Name = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := protohelpers.Skip(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return protohelpers.ErrInvalidLength - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} func (m *CreateQueryCheckpointOrder) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 diff --git a/internal/proto/servicepb/bucket.pb.go b/internal/proto/servicepb/bucket.pb.go index 47ad7263db..7cab5bddfc 100644 --- a/internal/proto/servicepb/bucket.pb.go +++ b/internal/proto/servicepb/bucket.pb.go @@ -120,6 +120,15 @@ const ( // EphemeralEvictedCount / TransientUsedCount are informational and excluded // (cf. Index BuildStatus). CheckStoreErrorType_CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH CheckStoreErrorType = 18 + // Emitted when the numscript library projections (SubAttrNumscriptContent + // immutable version entries and SubAttrNumscriptVersion latest pointers) + // diverge from the state the checker re-derived by replaying SavedNumscript / + // DeleteLedger log payloads. Those projections are the source for reads, + // listing, version history and admission-side reference resolution; a stored + // content row that has no matching SavedNumscript, an altered content entry, + // or a latest pointer that is not the greatest saved semver is tampering. The + // audit chain is the source of truth. + CheckStoreErrorType_CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH CheckStoreErrorType = 19 ) // Enum value maps for CheckStoreErrorType. @@ -144,6 +153,7 @@ var ( 16: "CHECK_STORE_ERROR_TYPE_UNAUDITED_LEDGER", 17: "CHECK_STORE_ERROR_TYPE_REFERENCE_MISMATCH", 18: "CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH", + 19: "CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH", } CheckStoreErrorType_value = map[string]int32{ "CHECK_STORE_ERROR_TYPE_UNSPECIFIED": 0, @@ -165,6 +175,7 @@ var ( "CHECK_STORE_ERROR_TYPE_UNAUDITED_LEDGER": 16, "CHECK_STORE_ERROR_TYPE_REFERENCE_MISMATCH": 17, "CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH": 18, + "CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH": 19, } ) @@ -388,7 +399,7 @@ func (x ListIndexesRequest_Scope) Number() protoreflect.EnumNumber { // Deprecated: Use ListIndexesRequest_Scope.Descriptor instead. func (ListIndexesRequest_Scope) EnumDescriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{118, 0} + return file_bucket_proto_rawDescGZIP(), []int{119, 0} } type GetAccountRequest struct { @@ -1184,7 +1195,6 @@ type Request struct { // *Request_CreateIndex // *Request_DropIndex // *Request_SaveNumscript - // *Request_DeleteNumscript // *Request_AddAccountType // *Request_RemoveAccountType // *Request_SetDefaultEnforcementMode @@ -1452,15 +1462,6 @@ func (x *Request) GetSaveNumscript() *SaveNumscriptRequest { return nil } -func (x *Request) GetDeleteNumscript() *DeleteNumscriptRequest { - if x != nil { - if x, ok := x.Type.(*Request_DeleteNumscript); ok { - return x.DeleteNumscript - } - } - return nil -} - func (x *Request) GetAddAccountType() *AddAccountTypeLedgerRequest { if x != nil { if x, ok := x.Type.(*Request_AddAccountType); ok { @@ -1642,10 +1643,6 @@ type Request_SaveNumscript struct { SaveNumscript *SaveNumscriptRequest `protobuf:"bytes,27,opt,name=save_numscript,json=saveNumscript,proto3,oneof"` } -type Request_DeleteNumscript struct { - DeleteNumscript *DeleteNumscriptRequest `protobuf:"bytes,28,opt,name=delete_numscript,json=deleteNumscript,proto3,oneof"` -} - type Request_AddAccountType struct { AddAccountType *AddAccountTypeLedgerRequest `protobuf:"bytes,29,opt,name=add_account_type,json=addAccountType,proto3,oneof"` } @@ -1730,8 +1727,6 @@ func (*Request_DropIndex) isRequest_Type() {} func (*Request_SaveNumscript) isRequest_Type() {} -func (*Request_DeleteNumscript) isRequest_Type() {} - func (*Request_AddAccountType) isRequest_Type() {} func (*Request_RemoveAccountType) isRequest_Type() {} @@ -2866,8 +2861,8 @@ func (x *DropIndexRequest) GetId() *commonpb.IndexID { return nil } -// SaveNumscriptRequest saves a numscript to the library. -// version must be a valid semver string (e.g. "1.0.0") or "latest" to overwrite the most recent version. +// SaveNumscriptRequest appends an immutable version to the library. version +// must be an explicit full semver (e.g. "1.0.0"). type SaveNumscriptRequest struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -2936,29 +2931,33 @@ func (x *SaveNumscriptRequest) GetLedger() string { return "" } -// DeleteNumscriptRequest removes a numscript from the library (versions preserved). -type DeleteNumscriptRequest struct { +// GetNumscriptRequest retrieves a numscript by name and version selector. +// version accepts an exact semver, a partial selector (e.g. "1", "1.2"), or +// "" / "latest" for the greatest stored semver. +type GetNumscriptRequest struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Ledger string `protobuf:"bytes,2,opt,name=ledger,proto3" json:"ledger,omitempty"` + Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` // "" = latest (greatest stored semver) + Ledger string `protobuf:"bytes,3,opt,name=ledger,proto3" json:"ledger,omitempty"` + Read *commonpb.ReadOptions `protobuf:"bytes,4,opt,name=read,proto3" json:"read,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteNumscriptRequest) Reset() { - *x = DeleteNumscriptRequest{} +func (x *GetNumscriptRequest) Reset() { + *x = GetNumscriptRequest{} mi := &file_bucket_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteNumscriptRequest) String() string { +func (x *GetNumscriptRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteNumscriptRequest) ProtoMessage() {} +func (*GetNumscriptRequest) ProtoMessage() {} -func (x *DeleteNumscriptRequest) ProtoReflect() protoreflect.Message { +func (x *GetNumscriptRequest) ProtoReflect() protoreflect.Message { mi := &file_bucket_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -2970,50 +2969,62 @@ func (x *DeleteNumscriptRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteNumscriptRequest.ProtoReflect.Descriptor instead. -func (*DeleteNumscriptRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use GetNumscriptRequest.ProtoReflect.Descriptor instead. +func (*GetNumscriptRequest) Descriptor() ([]byte, []int) { return file_bucket_proto_rawDescGZIP(), []int{38} } -func (x *DeleteNumscriptRequest) GetName() string { +func (x *GetNumscriptRequest) GetName() string { if x != nil { return x.Name } return "" } -func (x *DeleteNumscriptRequest) GetLedger() string { +func (x *GetNumscriptRequest) GetVersion() string { + if x != nil { + return x.Version + } + return "" +} + +func (x *GetNumscriptRequest) GetLedger() string { if x != nil { return x.Ledger } return "" } -// GetNumscriptRequest retrieves a numscript by name and optional version. -type GetNumscriptRequest struct { +func (x *GetNumscriptRequest) GetRead() *commonpb.ReadOptions { + if x != nil { + return x.Read + } + return nil +} + +// ListNumscriptsRequest lists all numscripts for a ledger (greatest version of each). +type ListNumscriptsRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` - Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"` // "" = latest - Ledger string `protobuf:"bytes,3,opt,name=ledger,proto3" json:"ledger,omitempty"` - Read *commonpb.ReadOptions `protobuf:"bytes,4,opt,name=read,proto3" json:"read,omitempty"` + Ledger string `protobuf:"bytes,1,opt,name=ledger,proto3" json:"ledger,omitempty"` + Options *commonpb.ListOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *GetNumscriptRequest) Reset() { - *x = GetNumscriptRequest{} +func (x *ListNumscriptsRequest) Reset() { + *x = ListNumscriptsRequest{} mi := &file_bucket_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *GetNumscriptRequest) String() string { +func (x *ListNumscriptsRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*GetNumscriptRequest) ProtoMessage() {} +func (*ListNumscriptsRequest) ProtoMessage() {} -func (x *GetNumscriptRequest) ProtoReflect() protoreflect.Message { +func (x *ListNumscriptsRequest) ProtoReflect() protoreflect.Message { mi := &file_bucket_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -3025,63 +3036,111 @@ func (x *GetNumscriptRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use GetNumscriptRequest.ProtoReflect.Descriptor instead. -func (*GetNumscriptRequest) Descriptor() ([]byte, []int) { +// Deprecated: Use ListNumscriptsRequest.ProtoReflect.Descriptor instead. +func (*ListNumscriptsRequest) Descriptor() ([]byte, []int) { return file_bucket_proto_rawDescGZIP(), []int{39} } -func (x *GetNumscriptRequest) GetName() string { +func (x *ListNumscriptsRequest) GetLedger() string { if x != nil { - return x.Name + return x.Ledger } return "" } -func (x *GetNumscriptRequest) GetVersion() string { +func (x *ListNumscriptsRequest) GetOptions() *commonpb.ListOptions { if x != nil { - return x.Version + return x.Options } - return "" + return nil } -func (x *GetNumscriptRequest) GetLedger() string { +// ListNumscriptVersionsRequest lists every stored version of a single numscript. +type ListNumscriptVersionsRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + Ledger string `protobuf:"bytes,1,opt,name=ledger,proto3" json:"ledger,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + Read *commonpb.ReadOptions `protobuf:"bytes,3,opt,name=read,proto3" json:"read,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ListNumscriptVersionsRequest) Reset() { + *x = ListNumscriptVersionsRequest{} + mi := &file_bucket_proto_msgTypes[40] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ListNumscriptVersionsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ListNumscriptVersionsRequest) ProtoMessage() {} + +func (x *ListNumscriptVersionsRequest) ProtoReflect() protoreflect.Message { + mi := &file_bucket_proto_msgTypes[40] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ListNumscriptVersionsRequest.ProtoReflect.Descriptor instead. +func (*ListNumscriptVersionsRequest) Descriptor() ([]byte, []int) { + return file_bucket_proto_rawDescGZIP(), []int{40} +} + +func (x *ListNumscriptVersionsRequest) GetLedger() string { if x != nil { return x.Ledger } return "" } -func (x *GetNumscriptRequest) GetRead() *commonpb.ReadOptions { +func (x *ListNumscriptVersionsRequest) GetName() string { + if x != nil { + return x.Name + } + return "" +} + +func (x *ListNumscriptVersionsRequest) GetRead() *commonpb.ReadOptions { if x != nil { return x.Read } return nil } -// ListNumscriptsRequest lists all numscripts for a ledger (latest version of each). -type ListNumscriptsRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - Ledger string `protobuf:"bytes,1,opt,name=ledger,proto3" json:"ledger,omitempty"` - Options *commonpb.ListOptions `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` +// ListNumscriptVersionsResponse carries the numscript's history: the current +// latest (greatest stored semver) and every stored version. +type ListNumscriptVersionsResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + LatestVersion string `protobuf:"bytes,1,opt,name=latest_version,json=latestVersion,proto3" json:"latest_version,omitempty"` + Versions []*commonpb.NumscriptVersionEntry `protobuf:"bytes,2,rep,name=versions,proto3" json:"versions,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ListNumscriptsRequest) Reset() { - *x = ListNumscriptsRequest{} - mi := &file_bucket_proto_msgTypes[40] +func (x *ListNumscriptVersionsResponse) Reset() { + *x = ListNumscriptVersionsResponse{} + mi := &file_bucket_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ListNumscriptsRequest) String() string { +func (x *ListNumscriptVersionsResponse) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ListNumscriptsRequest) ProtoMessage() {} +func (*ListNumscriptVersionsResponse) ProtoMessage() {} -func (x *ListNumscriptsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[40] +func (x *ListNumscriptVersionsResponse) ProtoReflect() protoreflect.Message { + mi := &file_bucket_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3092,21 +3151,21 @@ func (x *ListNumscriptsRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ListNumscriptsRequest.ProtoReflect.Descriptor instead. -func (*ListNumscriptsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{40} +// Deprecated: Use ListNumscriptVersionsResponse.ProtoReflect.Descriptor instead. +func (*ListNumscriptVersionsResponse) Descriptor() ([]byte, []int) { + return file_bucket_proto_rawDescGZIP(), []int{41} } -func (x *ListNumscriptsRequest) GetLedger() string { +func (x *ListNumscriptVersionsResponse) GetLatestVersion() string { if x != nil { - return x.Ledger + return x.LatestVersion } return "" } -func (x *ListNumscriptsRequest) GetOptions() *commonpb.ListOptions { +func (x *ListNumscriptVersionsResponse) GetVersions() []*commonpb.NumscriptVersionEntry { if x != nil { - return x.Options + return x.Versions } return nil } @@ -3125,7 +3184,7 @@ type GetTemplateUsageRequest struct { func (x *GetTemplateUsageRequest) Reset() { *x = GetTemplateUsageRequest{} - mi := &file_bucket_proto_msgTypes[41] + mi := &file_bucket_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3137,7 +3196,7 @@ func (x *GetTemplateUsageRequest) String() string { func (*GetTemplateUsageRequest) ProtoMessage() {} func (x *GetTemplateUsageRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[41] + mi := &file_bucket_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3150,7 +3209,7 @@ func (x *GetTemplateUsageRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTemplateUsageRequest.ProtoReflect.Descriptor instead. func (*GetTemplateUsageRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{41} + return file_bucket_proto_rawDescGZIP(), []int{42} } func (x *GetTemplateUsageRequest) GetLedger() string { @@ -3179,7 +3238,7 @@ type ScriptReference struct { func (x *ScriptReference) Reset() { *x = ScriptReference{} - mi := &file_bucket_proto_msgTypes[42] + mi := &file_bucket_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3191,7 +3250,7 @@ func (x *ScriptReference) String() string { func (*ScriptReference) ProtoMessage() {} func (x *ScriptReference) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[42] + mi := &file_bucket_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3204,7 +3263,7 @@ func (x *ScriptReference) ProtoReflect() protoreflect.Message { // Deprecated: Use ScriptReference.ProtoReflect.Descriptor instead. func (*ScriptReference) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{42} + return file_bucket_proto_rawDescGZIP(), []int{43} } func (x *ScriptReference) GetName() string { @@ -3238,7 +3297,7 @@ type SetQueryCheckpointScheduleRequest struct { func (x *SetQueryCheckpointScheduleRequest) Reset() { *x = SetQueryCheckpointScheduleRequest{} - mi := &file_bucket_proto_msgTypes[43] + mi := &file_bucket_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3250,7 +3309,7 @@ func (x *SetQueryCheckpointScheduleRequest) String() string { func (*SetQueryCheckpointScheduleRequest) ProtoMessage() {} func (x *SetQueryCheckpointScheduleRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[43] + mi := &file_bucket_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3263,7 +3322,7 @@ func (x *SetQueryCheckpointScheduleRequest) ProtoReflect() protoreflect.Message // Deprecated: Use SetQueryCheckpointScheduleRequest.ProtoReflect.Descriptor instead. func (*SetQueryCheckpointScheduleRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{43} + return file_bucket_proto_rawDescGZIP(), []int{44} } func (x *SetQueryCheckpointScheduleRequest) GetCron() string { @@ -3282,7 +3341,7 @@ type DeleteQueryCheckpointScheduleRequest struct { func (x *DeleteQueryCheckpointScheduleRequest) Reset() { *x = DeleteQueryCheckpointScheduleRequest{} - mi := &file_bucket_proto_msgTypes[44] + mi := &file_bucket_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3294,7 +3353,7 @@ func (x *DeleteQueryCheckpointScheduleRequest) String() string { func (*DeleteQueryCheckpointScheduleRequest) ProtoMessage() {} func (x *DeleteQueryCheckpointScheduleRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[44] + mi := &file_bucket_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3307,7 +3366,7 @@ func (x *DeleteQueryCheckpointScheduleRequest) ProtoReflect() protoreflect.Messa // Deprecated: Use DeleteQueryCheckpointScheduleRequest.ProtoReflect.Descriptor instead. func (*DeleteQueryCheckpointScheduleRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{44} + return file_bucket_proto_rawDescGZIP(), []int{45} } type GetChapterScheduleRequest struct { @@ -3318,7 +3377,7 @@ type GetChapterScheduleRequest struct { func (x *GetChapterScheduleRequest) Reset() { *x = GetChapterScheduleRequest{} - mi := &file_bucket_proto_msgTypes[45] + mi := &file_bucket_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3330,7 +3389,7 @@ func (x *GetChapterScheduleRequest) String() string { func (*GetChapterScheduleRequest) ProtoMessage() {} func (x *GetChapterScheduleRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[45] + mi := &file_bucket_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3343,7 +3402,7 @@ func (x *GetChapterScheduleRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetChapterScheduleRequest.ProtoReflect.Descriptor instead. func (*GetChapterScheduleRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{45} + return file_bucket_proto_rawDescGZIP(), []int{46} } type GetChapterScheduleResponse struct { @@ -3355,7 +3414,7 @@ type GetChapterScheduleResponse struct { func (x *GetChapterScheduleResponse) Reset() { *x = GetChapterScheduleResponse{} - mi := &file_bucket_proto_msgTypes[46] + mi := &file_bucket_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3367,7 +3426,7 @@ func (x *GetChapterScheduleResponse) String() string { func (*GetChapterScheduleResponse) ProtoMessage() {} func (x *GetChapterScheduleResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[46] + mi := &file_bucket_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3380,7 +3439,7 @@ func (x *GetChapterScheduleResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetChapterScheduleResponse.ProtoReflect.Descriptor instead. func (*GetChapterScheduleResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{46} + return file_bucket_proto_rawDescGZIP(), []int{47} } func (x *GetChapterScheduleResponse) GetCron() string { @@ -3398,7 +3457,7 @@ type DiscoveryRequest struct { func (x *DiscoveryRequest) Reset() { *x = DiscoveryRequest{} - mi := &file_bucket_proto_msgTypes[47] + mi := &file_bucket_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3410,7 +3469,7 @@ func (x *DiscoveryRequest) String() string { func (*DiscoveryRequest) ProtoMessage() {} func (x *DiscoveryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[47] + mi := &file_bucket_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3423,7 +3482,7 @@ func (x *DiscoveryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DiscoveryRequest.ProtoReflect.Descriptor instead. func (*DiscoveryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{47} + return file_bucket_proto_rawDescGZIP(), []int{48} } // ServerInfo carries the server build metadata (unauthenticated). @@ -3439,7 +3498,7 @@ type ServerInfo struct { func (x *ServerInfo) Reset() { *x = ServerInfo{} - mi := &file_bucket_proto_msgTypes[48] + mi := &file_bucket_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3451,7 +3510,7 @@ func (x *ServerInfo) String() string { func (*ServerInfo) ProtoMessage() {} func (x *ServerInfo) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[48] + mi := &file_bucket_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3464,7 +3523,7 @@ func (x *ServerInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ServerInfo.ProtoReflect.Descriptor instead. func (*ServerInfo) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{48} + return file_bucket_proto_rawDescGZIP(), []int{49} } func (x *ServerInfo) GetVersion() string { @@ -3505,7 +3564,7 @@ type DiscoveryResponse struct { func (x *DiscoveryResponse) Reset() { *x = DiscoveryResponse{} - mi := &file_bucket_proto_msgTypes[49] + mi := &file_bucket_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3517,7 +3576,7 @@ func (x *DiscoveryResponse) String() string { func (*DiscoveryResponse) ProtoMessage() {} func (x *DiscoveryResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[49] + mi := &file_bucket_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3530,7 +3589,7 @@ func (x *DiscoveryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DiscoveryResponse.ProtoReflect.Descriptor instead. func (*DiscoveryResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{49} + return file_bucket_proto_rawDescGZIP(), []int{50} } func (x *DiscoveryResponse) GetResponseSigning() *ResponseSigningInfo { @@ -3558,7 +3617,7 @@ type ResponseSigningInfo struct { func (x *ResponseSigningInfo) Reset() { *x = ResponseSigningInfo{} - mi := &file_bucket_proto_msgTypes[50] + mi := &file_bucket_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3570,7 +3629,7 @@ func (x *ResponseSigningInfo) String() string { func (*ResponseSigningInfo) ProtoMessage() {} func (x *ResponseSigningInfo) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[50] + mi := &file_bucket_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3583,7 +3642,7 @@ func (x *ResponseSigningInfo) ProtoReflect() protoreflect.Message { // Deprecated: Use ResponseSigningInfo.ProtoReflect.Descriptor instead. func (*ResponseSigningInfo) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{50} + return file_bucket_proto_rawDescGZIP(), []int{51} } func (x *ResponseSigningInfo) GetPublicKey() []byte { @@ -3618,7 +3677,7 @@ type CreateTransactionPayload struct { func (x *CreateTransactionPayload) Reset() { *x = CreateTransactionPayload{} - mi := &file_bucket_proto_msgTypes[51] + mi := &file_bucket_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3630,7 +3689,7 @@ func (x *CreateTransactionPayload) String() string { func (*CreateTransactionPayload) ProtoMessage() {} func (x *CreateTransactionPayload) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[51] + mi := &file_bucket_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3643,7 +3702,7 @@ func (x *CreateTransactionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateTransactionPayload.ProtoReflect.Descriptor instead. func (*CreateTransactionPayload) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{51} + return file_bucket_proto_rawDescGZIP(), []int{52} } func (x *CreateTransactionPayload) GetPostings() []*commonpb.Posting { @@ -3724,7 +3783,7 @@ type RevertTransactionPayload struct { func (x *RevertTransactionPayload) Reset() { *x = RevertTransactionPayload{} - mi := &file_bucket_proto_msgTypes[52] + mi := &file_bucket_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3736,7 +3795,7 @@ func (x *RevertTransactionPayload) String() string { func (*RevertTransactionPayload) ProtoMessage() {} func (x *RevertTransactionPayload) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[52] + mi := &file_bucket_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3749,7 +3808,7 @@ func (x *RevertTransactionPayload) ProtoReflect() protoreflect.Message { // Deprecated: Use RevertTransactionPayload.ProtoReflect.Descriptor instead. func (*RevertTransactionPayload) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{52} + return file_bucket_proto_rawDescGZIP(), []int{53} } func (x *RevertTransactionPayload) GetTransactionId() uint64 { @@ -3819,7 +3878,7 @@ type LedgerAction struct { func (x *LedgerAction) Reset() { *x = LedgerAction{} - mi := &file_bucket_proto_msgTypes[53] + mi := &file_bucket_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3831,7 +3890,7 @@ func (x *LedgerAction) String() string { func (*LedgerAction) ProtoMessage() {} func (x *LedgerAction) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[53] + mi := &file_bucket_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3844,7 +3903,7 @@ func (x *LedgerAction) ProtoReflect() protoreflect.Message { // Deprecated: Use LedgerAction.ProtoReflect.Descriptor instead. func (*LedgerAction) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{53} + return file_bucket_proto_rawDescGZIP(), []int{54} } func (x *LedgerAction) GetData() isLedgerAction_Data { @@ -3987,7 +4046,7 @@ type LedgerApplyRequest struct { func (x *LedgerApplyRequest) Reset() { *x = LedgerApplyRequest{} - mi := &file_bucket_proto_msgTypes[54] + mi := &file_bucket_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3999,7 +4058,7 @@ func (x *LedgerApplyRequest) String() string { func (*LedgerApplyRequest) ProtoMessage() {} func (x *LedgerApplyRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[54] + mi := &file_bucket_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4012,7 +4071,7 @@ func (x *LedgerApplyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use LedgerApplyRequest.ProtoReflect.Descriptor instead. func (*LedgerApplyRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{54} + return file_bucket_proto_rawDescGZIP(), []int{55} } func (x *LedgerApplyRequest) GetLedger() string { @@ -4046,7 +4105,7 @@ type AddAccountTypeRequest struct { func (x *AddAccountTypeRequest) Reset() { *x = AddAccountTypeRequest{} - mi := &file_bucket_proto_msgTypes[55] + mi := &file_bucket_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4058,7 +4117,7 @@ func (x *AddAccountTypeRequest) String() string { func (*AddAccountTypeRequest) ProtoMessage() {} func (x *AddAccountTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[55] + mi := &file_bucket_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4071,7 +4130,7 @@ func (x *AddAccountTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAccountTypeRequest.ProtoReflect.Descriptor instead. func (*AddAccountTypeRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{55} + return file_bucket_proto_rawDescGZIP(), []int{56} } func (x *AddAccountTypeRequest) GetAccountType() *commonpb.AccountType { @@ -4091,7 +4150,7 @@ type RemoveAccountTypeRequest struct { func (x *RemoveAccountTypeRequest) Reset() { *x = RemoveAccountTypeRequest{} - mi := &file_bucket_proto_msgTypes[56] + mi := &file_bucket_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4103,7 +4162,7 @@ func (x *RemoveAccountTypeRequest) String() string { func (*RemoveAccountTypeRequest) ProtoMessage() {} func (x *RemoveAccountTypeRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[56] + mi := &file_bucket_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4116,7 +4175,7 @@ func (x *RemoveAccountTypeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveAccountTypeRequest.ProtoReflect.Descriptor instead. func (*RemoveAccountTypeRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{56} + return file_bucket_proto_rawDescGZIP(), []int{57} } func (x *RemoveAccountTypeRequest) GetName() string { @@ -4136,7 +4195,7 @@ type SetDefaultEnforcementModeRequest struct { func (x *SetDefaultEnforcementModeRequest) Reset() { *x = SetDefaultEnforcementModeRequest{} - mi := &file_bucket_proto_msgTypes[57] + mi := &file_bucket_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4148,7 +4207,7 @@ func (x *SetDefaultEnforcementModeRequest) String() string { func (*SetDefaultEnforcementModeRequest) ProtoMessage() {} func (x *SetDefaultEnforcementModeRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[57] + mi := &file_bucket_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4161,7 +4220,7 @@ func (x *SetDefaultEnforcementModeRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SetDefaultEnforcementModeRequest.ProtoReflect.Descriptor instead. func (*SetDefaultEnforcementModeRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{57} + return file_bucket_proto_rawDescGZIP(), []int{58} } func (x *SetDefaultEnforcementModeRequest) GetEnforcementMode() commonpb.ChartEnforcementMode { @@ -4182,7 +4241,7 @@ type SetDefaultEnforcementModeLedgerRequest struct { func (x *SetDefaultEnforcementModeLedgerRequest) Reset() { *x = SetDefaultEnforcementModeLedgerRequest{} - mi := &file_bucket_proto_msgTypes[58] + mi := &file_bucket_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4194,7 +4253,7 @@ func (x *SetDefaultEnforcementModeLedgerRequest) String() string { func (*SetDefaultEnforcementModeLedgerRequest) ProtoMessage() {} func (x *SetDefaultEnforcementModeLedgerRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[58] + mi := &file_bucket_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4207,7 +4266,7 @@ func (x *SetDefaultEnforcementModeLedgerRequest) ProtoReflect() protoreflect.Mes // Deprecated: Use SetDefaultEnforcementModeLedgerRequest.ProtoReflect.Descriptor instead. func (*SetDefaultEnforcementModeLedgerRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{58} + return file_bucket_proto_rawDescGZIP(), []int{59} } func (x *SetDefaultEnforcementModeLedgerRequest) GetLedger() string { @@ -4235,7 +4294,7 @@ type AddAccountTypeLedgerRequest struct { func (x *AddAccountTypeLedgerRequest) Reset() { *x = AddAccountTypeLedgerRequest{} - mi := &file_bucket_proto_msgTypes[59] + mi := &file_bucket_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4247,7 +4306,7 @@ func (x *AddAccountTypeLedgerRequest) String() string { func (*AddAccountTypeLedgerRequest) ProtoMessage() {} func (x *AddAccountTypeLedgerRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[59] + mi := &file_bucket_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4260,7 +4319,7 @@ func (x *AddAccountTypeLedgerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AddAccountTypeLedgerRequest.ProtoReflect.Descriptor instead. func (*AddAccountTypeLedgerRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{59} + return file_bucket_proto_rawDescGZIP(), []int{60} } func (x *AddAccountTypeLedgerRequest) GetLedger() string { @@ -4288,7 +4347,7 @@ type RemoveAccountTypeLedgerRequest struct { func (x *RemoveAccountTypeLedgerRequest) Reset() { *x = RemoveAccountTypeLedgerRequest{} - mi := &file_bucket_proto_msgTypes[60] + mi := &file_bucket_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4300,7 +4359,7 @@ func (x *RemoveAccountTypeLedgerRequest) String() string { func (*RemoveAccountTypeLedgerRequest) ProtoMessage() {} func (x *RemoveAccountTypeLedgerRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[60] + mi := &file_bucket_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4313,7 +4372,7 @@ func (x *RemoveAccountTypeLedgerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RemoveAccountTypeLedgerRequest.ProtoReflect.Descriptor instead. func (*RemoveAccountTypeLedgerRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{60} + return file_bucket_proto_rawDescGZIP(), []int{61} } func (x *RemoveAccountTypeLedgerRequest) GetLedger() string { @@ -4340,7 +4399,7 @@ type GetPrimaryMetricsRequest struct { func (x *GetPrimaryMetricsRequest) Reset() { *x = GetPrimaryMetricsRequest{} - mi := &file_bucket_proto_msgTypes[61] + mi := &file_bucket_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4352,7 +4411,7 @@ func (x *GetPrimaryMetricsRequest) String() string { func (*GetPrimaryMetricsRequest) ProtoMessage() {} func (x *GetPrimaryMetricsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[61] + mi := &file_bucket_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4365,7 +4424,7 @@ func (x *GetPrimaryMetricsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetPrimaryMetricsRequest.ProtoReflect.Descriptor instead. func (*GetPrimaryMetricsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{61} + return file_bucket_proto_rawDescGZIP(), []int{62} } func (x *GetPrimaryMetricsRequest) GetNodeId() uint32 { @@ -4387,7 +4446,7 @@ type GetPrimaryMetricsResponse struct { func (x *GetPrimaryMetricsResponse) Reset() { *x = GetPrimaryMetricsResponse{} - mi := &file_bucket_proto_msgTypes[62] + mi := &file_bucket_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4399,7 +4458,7 @@ func (x *GetPrimaryMetricsResponse) String() string { func (*GetPrimaryMetricsResponse) ProtoMessage() {} func (x *GetPrimaryMetricsResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[62] + mi := &file_bucket_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4412,7 +4471,7 @@ func (x *GetPrimaryMetricsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetPrimaryMetricsResponse.ProtoReflect.Descriptor instead. func (*GetPrimaryMetricsResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{62} + return file_bucket_proto_rawDescGZIP(), []int{63} } func (x *GetPrimaryMetricsResponse) GetAvailable() bool { @@ -4439,7 +4498,7 @@ type GetSecondaryMetricsRequest struct { func (x *GetSecondaryMetricsRequest) Reset() { *x = GetSecondaryMetricsRequest{} - mi := &file_bucket_proto_msgTypes[63] + mi := &file_bucket_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4451,7 +4510,7 @@ func (x *GetSecondaryMetricsRequest) String() string { func (*GetSecondaryMetricsRequest) ProtoMessage() {} func (x *GetSecondaryMetricsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[63] + mi := &file_bucket_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4464,7 +4523,7 @@ func (x *GetSecondaryMetricsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSecondaryMetricsRequest.ProtoReflect.Descriptor instead. func (*GetSecondaryMetricsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{63} + return file_bucket_proto_rawDescGZIP(), []int{64} } func (x *GetSecondaryMetricsRequest) GetNodeId() uint32 { @@ -4486,7 +4545,7 @@ type GetSecondaryMetricsResponse struct { func (x *GetSecondaryMetricsResponse) Reset() { *x = GetSecondaryMetricsResponse{} - mi := &file_bucket_proto_msgTypes[64] + mi := &file_bucket_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4498,7 +4557,7 @@ func (x *GetSecondaryMetricsResponse) String() string { func (*GetSecondaryMetricsResponse) ProtoMessage() {} func (x *GetSecondaryMetricsResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[64] + mi := &file_bucket_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4511,7 +4570,7 @@ func (x *GetSecondaryMetricsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetSecondaryMetricsResponse.ProtoReflect.Descriptor instead. func (*GetSecondaryMetricsResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{64} + return file_bucket_proto_rawDescGZIP(), []int{65} } func (x *GetSecondaryMetricsResponse) GetAvailable() bool { @@ -4548,7 +4607,7 @@ type PebbleMetrics struct { func (x *PebbleMetrics) Reset() { *x = PebbleMetrics{} - mi := &file_bucket_proto_msgTypes[65] + mi := &file_bucket_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4560,7 +4619,7 @@ func (x *PebbleMetrics) String() string { func (*PebbleMetrics) ProtoMessage() {} func (x *PebbleMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[65] + mi := &file_bucket_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4573,7 +4632,7 @@ func (x *PebbleMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use PebbleMetrics.ProtoReflect.Descriptor instead. func (*PebbleMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{65} + return file_bucket_proto_rawDescGZIP(), []int{66} } func (x *PebbleMetrics) GetBlockCache() *BlockCacheMetrics { @@ -4665,7 +4724,7 @@ type BlockCacheMetrics struct { func (x *BlockCacheMetrics) Reset() { *x = BlockCacheMetrics{} - mi := &file_bucket_proto_msgTypes[66] + mi := &file_bucket_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4677,7 +4736,7 @@ func (x *BlockCacheMetrics) String() string { func (*BlockCacheMetrics) ProtoMessage() {} func (x *BlockCacheMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[66] + mi := &file_bucket_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4690,7 +4749,7 @@ func (x *BlockCacheMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use BlockCacheMetrics.ProtoReflect.Descriptor instead. func (*BlockCacheMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{66} + return file_bucket_proto_rawDescGZIP(), []int{67} } func (x *BlockCacheMetrics) GetSize() int64 { @@ -4741,7 +4800,7 @@ type CompactMetrics struct { func (x *CompactMetrics) Reset() { *x = CompactMetrics{} - mi := &file_bucket_proto_msgTypes[67] + mi := &file_bucket_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4753,7 +4812,7 @@ func (x *CompactMetrics) String() string { func (*CompactMetrics) ProtoMessage() {} func (x *CompactMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[67] + mi := &file_bucket_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4766,7 +4825,7 @@ func (x *CompactMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use CompactMetrics.ProtoReflect.Descriptor instead. func (*CompactMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{67} + return file_bucket_proto_rawDescGZIP(), []int{68} } func (x *CompactMetrics) GetCount() int64 { @@ -4866,7 +4925,7 @@ type FlushMetrics struct { func (x *FlushMetrics) Reset() { *x = FlushMetrics{} - mi := &file_bucket_proto_msgTypes[68] + mi := &file_bucket_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4878,7 +4937,7 @@ func (x *FlushMetrics) String() string { func (*FlushMetrics) ProtoMessage() {} func (x *FlushMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[68] + mi := &file_bucket_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4891,7 +4950,7 @@ func (x *FlushMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use FlushMetrics.ProtoReflect.Descriptor instead. func (*FlushMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{68} + return file_bucket_proto_rawDescGZIP(), []int{69} } func (x *FlushMetrics) GetCount() int64 { @@ -4941,7 +5000,7 @@ type MemTableMetrics struct { func (x *MemTableMetrics) Reset() { *x = MemTableMetrics{} - mi := &file_bucket_proto_msgTypes[69] + mi := &file_bucket_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4953,7 +5012,7 @@ func (x *MemTableMetrics) String() string { func (*MemTableMetrics) ProtoMessage() {} func (x *MemTableMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[69] + mi := &file_bucket_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4966,7 +5025,7 @@ func (x *MemTableMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use MemTableMetrics.ProtoReflect.Descriptor instead. func (*MemTableMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{69} + return file_bucket_proto_rawDescGZIP(), []int{70} } func (x *MemTableMetrics) GetSize() uint64 { @@ -5009,7 +5068,7 @@ type SnapshotsMetrics struct { func (x *SnapshotsMetrics) Reset() { *x = SnapshotsMetrics{} - mi := &file_bucket_proto_msgTypes[70] + mi := &file_bucket_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5021,7 +5080,7 @@ func (x *SnapshotsMetrics) String() string { func (*SnapshotsMetrics) ProtoMessage() {} func (x *SnapshotsMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[70] + mi := &file_bucket_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5034,7 +5093,7 @@ func (x *SnapshotsMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use SnapshotsMetrics.ProtoReflect.Descriptor instead. func (*SnapshotsMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{70} + return file_bucket_proto_rawDescGZIP(), []int{71} } func (x *SnapshotsMetrics) GetCount() int32 { @@ -5077,7 +5136,7 @@ type TableMetrics struct { func (x *TableMetrics) Reset() { *x = TableMetrics{} - mi := &file_bucket_proto_msgTypes[71] + mi := &file_bucket_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5089,7 +5148,7 @@ func (x *TableMetrics) String() string { func (*TableMetrics) ProtoMessage() {} func (x *TableMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[71] + mi := &file_bucket_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5102,7 +5161,7 @@ func (x *TableMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use TableMetrics.ProtoReflect.Descriptor instead. func (*TableMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{71} + return file_bucket_proto_rawDescGZIP(), []int{72} } func (x *TableMetrics) GetZombieSize() uint64 { @@ -5145,7 +5204,7 @@ type TableCacheMetrics struct { func (x *TableCacheMetrics) Reset() { *x = TableCacheMetrics{} - mi := &file_bucket_proto_msgTypes[72] + mi := &file_bucket_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5157,7 +5216,7 @@ func (x *TableCacheMetrics) String() string { func (*TableCacheMetrics) ProtoMessage() {} func (x *TableCacheMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[72] + mi := &file_bucket_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5170,7 +5229,7 @@ func (x *TableCacheMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use TableCacheMetrics.ProtoReflect.Descriptor instead. func (*TableCacheMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{72} + return file_bucket_proto_rawDescGZIP(), []int{73} } func (x *TableCacheMetrics) GetSize() int64 { @@ -5214,7 +5273,7 @@ type WALMetrics struct { func (x *WALMetrics) Reset() { *x = WALMetrics{} - mi := &file_bucket_proto_msgTypes[73] + mi := &file_bucket_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5226,7 +5285,7 @@ func (x *WALMetrics) String() string { func (*WALMetrics) ProtoMessage() {} func (x *WALMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[73] + mi := &file_bucket_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5239,7 +5298,7 @@ func (x *WALMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use WALMetrics.ProtoReflect.Descriptor instead. func (*WALMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{73} + return file_bucket_proto_rawDescGZIP(), []int{74} } func (x *WALMetrics) GetFiles() int64 { @@ -5287,7 +5346,7 @@ type KeysMetrics struct { func (x *KeysMetrics) Reset() { *x = KeysMetrics{} - mi := &file_bucket_proto_msgTypes[74] + mi := &file_bucket_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5299,7 +5358,7 @@ func (x *KeysMetrics) String() string { func (*KeysMetrics) ProtoMessage() {} func (x *KeysMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[74] + mi := &file_bucket_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5312,7 +5371,7 @@ func (x *KeysMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use KeysMetrics.ProtoReflect.Descriptor instead. func (*KeysMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{74} + return file_bucket_proto_rawDescGZIP(), []int{75} } func (x *KeysMetrics) GetRangeKeySetsCount() uint64 { @@ -5351,7 +5410,7 @@ type LevelMetrics struct { func (x *LevelMetrics) Reset() { *x = LevelMetrics{} - mi := &file_bucket_proto_msgTypes[75] + mi := &file_bucket_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5363,7 +5422,7 @@ func (x *LevelMetrics) String() string { func (*LevelMetrics) ProtoMessage() {} func (x *LevelMetrics) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[75] + mi := &file_bucket_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5376,7 +5435,7 @@ func (x *LevelMetrics) ProtoReflect() protoreflect.Message { // Deprecated: Use LevelMetrics.ProtoReflect.Descriptor instead. func (*LevelMetrics) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{75} + return file_bucket_proto_rawDescGZIP(), []int{76} } func (x *LevelMetrics) GetLevel() int32 { @@ -5485,7 +5544,7 @@ type CheckStoreRequest struct { func (x *CheckStoreRequest) Reset() { *x = CheckStoreRequest{} - mi := &file_bucket_proto_msgTypes[76] + mi := &file_bucket_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5497,7 +5556,7 @@ func (x *CheckStoreRequest) String() string { func (*CheckStoreRequest) ProtoMessage() {} func (x *CheckStoreRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[76] + mi := &file_bucket_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5510,7 +5569,7 @@ func (x *CheckStoreRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckStoreRequest.ProtoReflect.Descriptor instead. func (*CheckStoreRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{76} + return file_bucket_proto_rawDescGZIP(), []int{77} } type CheckStoreEvent struct { @@ -5526,7 +5585,7 @@ type CheckStoreEvent struct { func (x *CheckStoreEvent) Reset() { *x = CheckStoreEvent{} - mi := &file_bucket_proto_msgTypes[77] + mi := &file_bucket_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5538,7 +5597,7 @@ func (x *CheckStoreEvent) String() string { func (*CheckStoreEvent) ProtoMessage() {} func (x *CheckStoreEvent) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[77] + mi := &file_bucket_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5551,7 +5610,7 @@ func (x *CheckStoreEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckStoreEvent.ProtoReflect.Descriptor instead. func (*CheckStoreEvent) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{77} + return file_bucket_proto_rawDescGZIP(), []int{78} } func (x *CheckStoreEvent) GetType() isCheckStoreEvent_Type { @@ -5610,7 +5669,7 @@ type CheckStoreError struct { func (x *CheckStoreError) Reset() { *x = CheckStoreError{} - mi := &file_bucket_proto_msgTypes[78] + mi := &file_bucket_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5622,7 +5681,7 @@ func (x *CheckStoreError) String() string { func (*CheckStoreError) ProtoMessage() {} func (x *CheckStoreError) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[78] + mi := &file_bucket_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5635,7 +5694,7 @@ func (x *CheckStoreError) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckStoreError.ProtoReflect.Descriptor instead. func (*CheckStoreError) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{78} + return file_bucket_proto_rawDescGZIP(), []int{79} } func (x *CheckStoreError) GetErrorType() CheckStoreErrorType { @@ -5697,7 +5756,7 @@ type CheckStoreProgress struct { func (x *CheckStoreProgress) Reset() { *x = CheckStoreProgress{} - mi := &file_bucket_proto_msgTypes[79] + mi := &file_bucket_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5709,7 +5768,7 @@ func (x *CheckStoreProgress) String() string { func (*CheckStoreProgress) ProtoMessage() {} func (x *CheckStoreProgress) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[79] + mi := &file_bucket_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5722,7 +5781,7 @@ func (x *CheckStoreProgress) ProtoReflect() protoreflect.Message { // Deprecated: Use CheckStoreProgress.ProtoReflect.Descriptor instead. func (*CheckStoreProgress) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{79} + return file_bucket_proto_rawDescGZIP(), []int{80} } func (x *CheckStoreProgress) GetLogsChecked() uint64 { @@ -5752,7 +5811,7 @@ type ListAuditEntriesRequest struct { func (x *ListAuditEntriesRequest) Reset() { *x = ListAuditEntriesRequest{} - mi := &file_bucket_proto_msgTypes[80] + mi := &file_bucket_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5764,7 +5823,7 @@ func (x *ListAuditEntriesRequest) String() string { func (*ListAuditEntriesRequest) ProtoMessage() {} func (x *ListAuditEntriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[80] + mi := &file_bucket_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5777,7 +5836,7 @@ func (x *ListAuditEntriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAuditEntriesRequest.ProtoReflect.Descriptor instead. func (*ListAuditEntriesRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{80} + return file_bucket_proto_rawDescGZIP(), []int{81} } func (x *ListAuditEntriesRequest) GetOptions() *commonpb.ListOptions { @@ -5796,7 +5855,7 @@ type GetAuditEntryRequest struct { func (x *GetAuditEntryRequest) Reset() { *x = GetAuditEntryRequest{} - mi := &file_bucket_proto_msgTypes[81] + mi := &file_bucket_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5808,7 +5867,7 @@ func (x *GetAuditEntryRequest) String() string { func (*GetAuditEntryRequest) ProtoMessage() {} func (x *GetAuditEntryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[81] + mi := &file_bucket_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5821,7 +5880,7 @@ func (x *GetAuditEntryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAuditEntryRequest.ProtoReflect.Descriptor instead. func (*GetAuditEntryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{81} + return file_bucket_proto_rawDescGZIP(), []int{82} } func (x *GetAuditEntryRequest) GetSequence() uint64 { @@ -5842,7 +5901,7 @@ type ListLogsRequest struct { func (x *ListLogsRequest) Reset() { *x = ListLogsRequest{} - mi := &file_bucket_proto_msgTypes[82] + mi := &file_bucket_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5854,7 +5913,7 @@ func (x *ListLogsRequest) String() string { func (*ListLogsRequest) ProtoMessage() {} func (x *ListLogsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[82] + mi := &file_bucket_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5867,7 +5926,7 @@ func (x *ListLogsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListLogsRequest.ProtoReflect.Descriptor instead. func (*ListLogsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{82} + return file_bucket_proto_rawDescGZIP(), []int{83} } func (x *ListLogsRequest) GetLedger() string { @@ -5895,7 +5954,7 @@ type GetLogRequest struct { func (x *GetLogRequest) Reset() { *x = GetLogRequest{} - mi := &file_bucket_proto_msgTypes[83] + mi := &file_bucket_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5907,7 +5966,7 @@ func (x *GetLogRequest) String() string { func (*GetLogRequest) ProtoMessage() {} func (x *GetLogRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[83] + mi := &file_bucket_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5920,7 +5979,7 @@ func (x *GetLogRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLogRequest.ProtoReflect.Descriptor instead. func (*GetLogRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{83} + return file_bucket_proto_rawDescGZIP(), []int{84} } func (x *GetLogRequest) GetSequence() uint64 { @@ -5945,7 +6004,7 @@ type GetEventsSinksRequest struct { func (x *GetEventsSinksRequest) Reset() { *x = GetEventsSinksRequest{} - mi := &file_bucket_proto_msgTypes[84] + mi := &file_bucket_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5957,7 +6016,7 @@ func (x *GetEventsSinksRequest) String() string { func (*GetEventsSinksRequest) ProtoMessage() {} func (x *GetEventsSinksRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[84] + mi := &file_bucket_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5970,7 +6029,7 @@ func (x *GetEventsSinksRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetEventsSinksRequest.ProtoReflect.Descriptor instead. func (*GetEventsSinksRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{84} + return file_bucket_proto_rawDescGZIP(), []int{85} } type GetEventsSinksResponse struct { @@ -5983,7 +6042,7 @@ type GetEventsSinksResponse struct { func (x *GetEventsSinksResponse) Reset() { *x = GetEventsSinksResponse{} - mi := &file_bucket_proto_msgTypes[85] + mi := &file_bucket_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5995,7 +6054,7 @@ func (x *GetEventsSinksResponse) String() string { func (*GetEventsSinksResponse) ProtoMessage() {} func (x *GetEventsSinksResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[85] + mi := &file_bucket_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6008,7 +6067,7 @@ func (x *GetEventsSinksResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetEventsSinksResponse.ProtoReflect.Descriptor instead. func (*GetEventsSinksResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{85} + return file_bucket_proto_rawDescGZIP(), []int{86} } func (x *GetEventsSinksResponse) GetSinks() []*commonpb.SinkConfig { @@ -6034,7 +6093,7 @@ type GetMetadataSchemaStatusRequest struct { func (x *GetMetadataSchemaStatusRequest) Reset() { *x = GetMetadataSchemaStatusRequest{} - mi := &file_bucket_proto_msgTypes[86] + mi := &file_bucket_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6046,7 +6105,7 @@ func (x *GetMetadataSchemaStatusRequest) String() string { func (*GetMetadataSchemaStatusRequest) ProtoMessage() {} func (x *GetMetadataSchemaStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[86] + mi := &file_bucket_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6059,7 +6118,7 @@ func (x *GetMetadataSchemaStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetMetadataSchemaStatusRequest.ProtoReflect.Descriptor instead. func (*GetMetadataSchemaStatusRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{86} + return file_bucket_proto_rawDescGZIP(), []int{87} } func (x *GetMetadataSchemaStatusRequest) GetLedger() string { @@ -6080,7 +6139,7 @@ type GetMetadataSchemaStatusResponse struct { func (x *GetMetadataSchemaStatusResponse) Reset() { *x = GetMetadataSchemaStatusResponse{} - mi := &file_bucket_proto_msgTypes[87] + mi := &file_bucket_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6092,7 +6151,7 @@ func (x *GetMetadataSchemaStatusResponse) String() string { func (*GetMetadataSchemaStatusResponse) ProtoMessage() {} func (x *GetMetadataSchemaStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[87] + mi := &file_bucket_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6105,7 +6164,7 @@ func (x *GetMetadataSchemaStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetMetadataSchemaStatusResponse.ProtoReflect.Descriptor instead. func (*GetMetadataSchemaStatusResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{87} + return file_bucket_proto_rawDescGZIP(), []int{88} } func (x *GetMetadataSchemaStatusResponse) GetAccountFields() map[string]*MetadataFieldStatus { @@ -6138,7 +6197,7 @@ type MetadataFieldStatus struct { func (x *MetadataFieldStatus) Reset() { *x = MetadataFieldStatus{} - mi := &file_bucket_proto_msgTypes[88] + mi := &file_bucket_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6150,7 +6209,7 @@ func (x *MetadataFieldStatus) String() string { func (*MetadataFieldStatus) ProtoMessage() {} func (x *MetadataFieldStatus) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[88] + mi := &file_bucket_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6163,7 +6222,7 @@ func (x *MetadataFieldStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use MetadataFieldStatus.ProtoReflect.Descriptor instead. func (*MetadataFieldStatus) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{88} + return file_bucket_proto_rawDescGZIP(), []int{89} } func (x *MetadataFieldStatus) GetDeclaredType() commonpb.MetadataType { @@ -6185,7 +6244,7 @@ type AnalyzeAccountsRequest struct { func (x *AnalyzeAccountsRequest) Reset() { *x = AnalyzeAccountsRequest{} - mi := &file_bucket_proto_msgTypes[89] + mi := &file_bucket_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6197,7 +6256,7 @@ func (x *AnalyzeAccountsRequest) String() string { func (*AnalyzeAccountsRequest) ProtoMessage() {} func (x *AnalyzeAccountsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[89] + mi := &file_bucket_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6210,7 +6269,7 @@ func (x *AnalyzeAccountsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeAccountsRequest.ProtoReflect.Descriptor instead. func (*AnalyzeAccountsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{89} + return file_bucket_proto_rawDescGZIP(), []int{90} } func (x *AnalyzeAccountsRequest) GetLedger() string { @@ -6237,7 +6296,7 @@ type AnalyzeAccountsResponse struct { func (x *AnalyzeAccountsResponse) Reset() { *x = AnalyzeAccountsResponse{} - mi := &file_bucket_proto_msgTypes[90] + mi := &file_bucket_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6249,7 +6308,7 @@ func (x *AnalyzeAccountsResponse) String() string { func (*AnalyzeAccountsResponse) ProtoMessage() {} func (x *AnalyzeAccountsResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[90] + mi := &file_bucket_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6262,7 +6321,7 @@ func (x *AnalyzeAccountsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeAccountsResponse.ProtoReflect.Descriptor instead. func (*AnalyzeAccountsResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{90} + return file_bucket_proto_rawDescGZIP(), []int{91} } func (x *AnalyzeAccountsResponse) GetPatterns() []*AccountPattern { @@ -6291,7 +6350,7 @@ type AnalyzeProgress struct { func (x *AnalyzeProgress) Reset() { *x = AnalyzeProgress{} - mi := &file_bucket_proto_msgTypes[91] + mi := &file_bucket_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6303,7 +6362,7 @@ func (x *AnalyzeProgress) String() string { func (*AnalyzeProgress) ProtoMessage() {} func (x *AnalyzeProgress) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[91] + mi := &file_bucket_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6316,7 +6375,7 @@ func (x *AnalyzeProgress) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeProgress.ProtoReflect.Descriptor instead. func (*AnalyzeProgress) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{91} + return file_bucket_proto_rawDescGZIP(), []int{92} } func (x *AnalyzeProgress) GetProcessed() uint64 { @@ -6354,7 +6413,7 @@ type AnalyzeAccountsEvent struct { func (x *AnalyzeAccountsEvent) Reset() { *x = AnalyzeAccountsEvent{} - mi := &file_bucket_proto_msgTypes[92] + mi := &file_bucket_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6366,7 +6425,7 @@ func (x *AnalyzeAccountsEvent) String() string { func (*AnalyzeAccountsEvent) ProtoMessage() {} func (x *AnalyzeAccountsEvent) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[92] + mi := &file_bucket_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6379,7 +6438,7 @@ func (x *AnalyzeAccountsEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeAccountsEvent.ProtoReflect.Descriptor instead. func (*AnalyzeAccountsEvent) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{92} + return file_bucket_proto_rawDescGZIP(), []int{93} } func (x *AnalyzeAccountsEvent) GetType() isAnalyzeAccountsEvent_Type { @@ -6437,7 +6496,7 @@ type AnalyzeTransactionsEvent struct { func (x *AnalyzeTransactionsEvent) Reset() { *x = AnalyzeTransactionsEvent{} - mi := &file_bucket_proto_msgTypes[93] + mi := &file_bucket_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6449,7 +6508,7 @@ func (x *AnalyzeTransactionsEvent) String() string { func (*AnalyzeTransactionsEvent) ProtoMessage() {} func (x *AnalyzeTransactionsEvent) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[93] + mi := &file_bucket_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6462,7 +6521,7 @@ func (x *AnalyzeTransactionsEvent) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeTransactionsEvent.ProtoReflect.Descriptor instead. func (*AnalyzeTransactionsEvent) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{93} + return file_bucket_proto_rawDescGZIP(), []int{94} } func (x *AnalyzeTransactionsEvent) GetType() isAnalyzeTransactionsEvent_Type { @@ -6520,7 +6579,7 @@ type AccountPattern struct { func (x *AccountPattern) Reset() { *x = AccountPattern{} - mi := &file_bucket_proto_msgTypes[94] + mi := &file_bucket_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6532,7 +6591,7 @@ func (x *AccountPattern) String() string { func (*AccountPattern) ProtoMessage() {} func (x *AccountPattern) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[94] + mi := &file_bucket_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6545,7 +6604,7 @@ func (x *AccountPattern) ProtoReflect() protoreflect.Message { // Deprecated: Use AccountPattern.ProtoReflect.Descriptor instead. func (*AccountPattern) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{94} + return file_bucket_proto_rawDescGZIP(), []int{95} } func (x *AccountPattern) GetPattern() string { @@ -6599,7 +6658,7 @@ type PatternSegment struct { func (x *PatternSegment) Reset() { *x = PatternSegment{} - mi := &file_bucket_proto_msgTypes[95] + mi := &file_bucket_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6611,7 +6670,7 @@ func (x *PatternSegment) String() string { func (*PatternSegment) ProtoMessage() {} func (x *PatternSegment) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[95] + mi := &file_bucket_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6624,7 +6683,7 @@ func (x *PatternSegment) ProtoReflect() protoreflect.Message { // Deprecated: Use PatternSegment.ProtoReflect.Descriptor instead. func (*PatternSegment) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{95} + return file_bucket_proto_rawDescGZIP(), []int{96} } func (x *PatternSegment) GetPosition() uint32 { @@ -6688,7 +6747,7 @@ type AnalyzeTransactionsRequest struct { func (x *AnalyzeTransactionsRequest) Reset() { *x = AnalyzeTransactionsRequest{} - mi := &file_bucket_proto_msgTypes[96] + mi := &file_bucket_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6700,7 +6759,7 @@ func (x *AnalyzeTransactionsRequest) String() string { func (*AnalyzeTransactionsRequest) ProtoMessage() {} func (x *AnalyzeTransactionsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[96] + mi := &file_bucket_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6713,7 +6772,7 @@ func (x *AnalyzeTransactionsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeTransactionsRequest.ProtoReflect.Descriptor instead. func (*AnalyzeTransactionsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{96} + return file_bucket_proto_rawDescGZIP(), []int{97} } func (x *AnalyzeTransactionsRequest) GetLedger() string { @@ -6741,7 +6800,7 @@ type AnalyzeTransactionsResponse struct { func (x *AnalyzeTransactionsResponse) Reset() { *x = AnalyzeTransactionsResponse{} - mi := &file_bucket_proto_msgTypes[97] + mi := &file_bucket_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6753,7 +6812,7 @@ func (x *AnalyzeTransactionsResponse) String() string { func (*AnalyzeTransactionsResponse) ProtoMessage() {} func (x *AnalyzeTransactionsResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[97] + mi := &file_bucket_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6766,7 +6825,7 @@ func (x *AnalyzeTransactionsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use AnalyzeTransactionsResponse.ProtoReflect.Descriptor instead. func (*AnalyzeTransactionsResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{97} + return file_bucket_proto_rawDescGZIP(), []int{98} } func (x *AnalyzeTransactionsResponse) GetFlowPatterns() []*FlowPattern { @@ -6809,7 +6868,7 @@ type FlowPattern struct { func (x *FlowPattern) Reset() { *x = FlowPattern{} - mi := &file_bucket_proto_msgTypes[98] + mi := &file_bucket_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6821,7 +6880,7 @@ func (x *FlowPattern) String() string { func (*FlowPattern) ProtoMessage() {} func (x *FlowPattern) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[98] + mi := &file_bucket_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6834,7 +6893,7 @@ func (x *FlowPattern) ProtoReflect() protoreflect.Message { // Deprecated: Use FlowPattern.ProtoReflect.Descriptor instead. func (*FlowPattern) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{98} + return file_bucket_proto_rawDescGZIP(), []int{99} } func (x *FlowPattern) GetSignature() string { @@ -6902,7 +6961,7 @@ type NormalizedPosting struct { func (x *NormalizedPosting) Reset() { *x = NormalizedPosting{} - mi := &file_bucket_proto_msgTypes[99] + mi := &file_bucket_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6914,7 +6973,7 @@ func (x *NormalizedPosting) String() string { func (*NormalizedPosting) ProtoMessage() {} func (x *NormalizedPosting) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[99] + mi := &file_bucket_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6927,7 +6986,7 @@ func (x *NormalizedPosting) ProtoReflect() protoreflect.Message { // Deprecated: Use NormalizedPosting.ProtoReflect.Descriptor instead. func (*NormalizedPosting) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{99} + return file_bucket_proto_rawDescGZIP(), []int{100} } func (x *NormalizedPosting) GetSourcePattern() string { @@ -6970,7 +7029,7 @@ type TemporalStats struct { func (x *TemporalStats) Reset() { *x = TemporalStats{} - mi := &file_bucket_proto_msgTypes[100] + mi := &file_bucket_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6982,7 +7041,7 @@ func (x *TemporalStats) String() string { func (*TemporalStats) ProtoMessage() {} func (x *TemporalStats) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[100] + mi := &file_bucket_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6995,7 +7054,7 @@ func (x *TemporalStats) ProtoReflect() protoreflect.Message { // Deprecated: Use TemporalStats.ProtoReflect.Descriptor instead. func (*TemporalStats) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{100} + return file_bucket_proto_rawDescGZIP(), []int{101} } func (x *TemporalStats) GetFirstSeen() *commonpb.Timestamp { @@ -7036,7 +7095,7 @@ type HourBucket struct { func (x *HourBucket) Reset() { *x = HourBucket{} - mi := &file_bucket_proto_msgTypes[101] + mi := &file_bucket_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7048,7 +7107,7 @@ func (x *HourBucket) String() string { func (*HourBucket) ProtoMessage() {} func (x *HourBucket) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[101] + mi := &file_bucket_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7061,7 +7120,7 @@ func (x *HourBucket) ProtoReflect() protoreflect.Message { // Deprecated: Use HourBucket.ProtoReflect.Descriptor instead. func (*HourBucket) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{101} + return file_bucket_proto_rawDescGZIP(), []int{102} } func (x *HourBucket) GetHour() uint32 { @@ -7092,7 +7151,7 @@ type AssetVolumeStats struct { func (x *AssetVolumeStats) Reset() { *x = AssetVolumeStats{} - mi := &file_bucket_proto_msgTypes[102] + mi := &file_bucket_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7104,7 +7163,7 @@ func (x *AssetVolumeStats) String() string { func (*AssetVolumeStats) ProtoMessage() {} func (x *AssetVolumeStats) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[102] + mi := &file_bucket_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7117,7 +7176,7 @@ func (x *AssetVolumeStats) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetVolumeStats.ProtoReflect.Descriptor instead. func (*AssetVolumeStats) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{102} + return file_bucket_proto_rawDescGZIP(), []int{103} } func (x *AssetVolumeStats) GetAsset() string { @@ -7172,7 +7231,7 @@ type CreatePreparedQueryRequest struct { func (x *CreatePreparedQueryRequest) Reset() { *x = CreatePreparedQueryRequest{} - mi := &file_bucket_proto_msgTypes[103] + mi := &file_bucket_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7184,7 +7243,7 @@ func (x *CreatePreparedQueryRequest) String() string { func (*CreatePreparedQueryRequest) ProtoMessage() {} func (x *CreatePreparedQueryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[103] + mi := &file_bucket_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7197,7 +7256,7 @@ func (x *CreatePreparedQueryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreatePreparedQueryRequest.ProtoReflect.Descriptor instead. func (*CreatePreparedQueryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{103} + return file_bucket_proto_rawDescGZIP(), []int{104} } func (x *CreatePreparedQueryRequest) GetLedger() string { @@ -7222,7 +7281,7 @@ type CreatePreparedQueryResponse struct { func (x *CreatePreparedQueryResponse) Reset() { *x = CreatePreparedQueryResponse{} - mi := &file_bucket_proto_msgTypes[104] + mi := &file_bucket_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7234,7 +7293,7 @@ func (x *CreatePreparedQueryResponse) String() string { func (*CreatePreparedQueryResponse) ProtoMessage() {} func (x *CreatePreparedQueryResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[104] + mi := &file_bucket_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7247,7 +7306,7 @@ func (x *CreatePreparedQueryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreatePreparedQueryResponse.ProtoReflect.Descriptor instead. func (*CreatePreparedQueryResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{104} + return file_bucket_proto_rawDescGZIP(), []int{105} } type UpdatePreparedQueryRequest struct { @@ -7261,7 +7320,7 @@ type UpdatePreparedQueryRequest struct { func (x *UpdatePreparedQueryRequest) Reset() { *x = UpdatePreparedQueryRequest{} - mi := &file_bucket_proto_msgTypes[105] + mi := &file_bucket_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7273,7 +7332,7 @@ func (x *UpdatePreparedQueryRequest) String() string { func (*UpdatePreparedQueryRequest) ProtoMessage() {} func (x *UpdatePreparedQueryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[105] + mi := &file_bucket_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7286,7 +7345,7 @@ func (x *UpdatePreparedQueryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdatePreparedQueryRequest.ProtoReflect.Descriptor instead. func (*UpdatePreparedQueryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{105} + return file_bucket_proto_rawDescGZIP(), []int{106} } func (x *UpdatePreparedQueryRequest) GetLedger() string { @@ -7318,7 +7377,7 @@ type UpdatePreparedQueryResponse struct { func (x *UpdatePreparedQueryResponse) Reset() { *x = UpdatePreparedQueryResponse{} - mi := &file_bucket_proto_msgTypes[106] + mi := &file_bucket_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7330,7 +7389,7 @@ func (x *UpdatePreparedQueryResponse) String() string { func (*UpdatePreparedQueryResponse) ProtoMessage() {} func (x *UpdatePreparedQueryResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[106] + mi := &file_bucket_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7343,7 +7402,7 @@ func (x *UpdatePreparedQueryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdatePreparedQueryResponse.ProtoReflect.Descriptor instead. func (*UpdatePreparedQueryResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{106} + return file_bucket_proto_rawDescGZIP(), []int{107} } type DeletePreparedQueryRequest struct { @@ -7356,7 +7415,7 @@ type DeletePreparedQueryRequest struct { func (x *DeletePreparedQueryRequest) Reset() { *x = DeletePreparedQueryRequest{} - mi := &file_bucket_proto_msgTypes[107] + mi := &file_bucket_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7368,7 +7427,7 @@ func (x *DeletePreparedQueryRequest) String() string { func (*DeletePreparedQueryRequest) ProtoMessage() {} func (x *DeletePreparedQueryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[107] + mi := &file_bucket_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7381,7 +7440,7 @@ func (x *DeletePreparedQueryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeletePreparedQueryRequest.ProtoReflect.Descriptor instead. func (*DeletePreparedQueryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{107} + return file_bucket_proto_rawDescGZIP(), []int{108} } func (x *DeletePreparedQueryRequest) GetLedger() string { @@ -7406,7 +7465,7 @@ type DeletePreparedQueryResponse struct { func (x *DeletePreparedQueryResponse) Reset() { *x = DeletePreparedQueryResponse{} - mi := &file_bucket_proto_msgTypes[108] + mi := &file_bucket_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7418,7 +7477,7 @@ func (x *DeletePreparedQueryResponse) String() string { func (*DeletePreparedQueryResponse) ProtoMessage() {} func (x *DeletePreparedQueryResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[108] + mi := &file_bucket_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7431,7 +7490,7 @@ func (x *DeletePreparedQueryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeletePreparedQueryResponse.ProtoReflect.Descriptor instead. func (*DeletePreparedQueryResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{108} + return file_bucket_proto_rawDescGZIP(), []int{109} } type ListPreparedQueriesRequest struct { @@ -7443,7 +7502,7 @@ type ListPreparedQueriesRequest struct { func (x *ListPreparedQueriesRequest) Reset() { *x = ListPreparedQueriesRequest{} - mi := &file_bucket_proto_msgTypes[109] + mi := &file_bucket_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7455,7 +7514,7 @@ func (x *ListPreparedQueriesRequest) String() string { func (*ListPreparedQueriesRequest) ProtoMessage() {} func (x *ListPreparedQueriesRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[109] + mi := &file_bucket_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7468,7 +7527,7 @@ func (x *ListPreparedQueriesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListPreparedQueriesRequest.ProtoReflect.Descriptor instead. func (*ListPreparedQueriesRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{109} + return file_bucket_proto_rawDescGZIP(), []int{110} } func (x *ListPreparedQueriesRequest) GetLedger() string { @@ -7487,7 +7546,7 @@ type ListPreparedQueriesResponse struct { func (x *ListPreparedQueriesResponse) Reset() { *x = ListPreparedQueriesResponse{} - mi := &file_bucket_proto_msgTypes[110] + mi := &file_bucket_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7499,7 +7558,7 @@ func (x *ListPreparedQueriesResponse) String() string { func (*ListPreparedQueriesResponse) ProtoMessage() {} func (x *ListPreparedQueriesResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[110] + mi := &file_bucket_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7512,7 +7571,7 @@ func (x *ListPreparedQueriesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListPreparedQueriesResponse.ProtoReflect.Descriptor instead. func (*ListPreparedQueriesResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{110} + return file_bucket_proto_rawDescGZIP(), []int{111} } func (x *ListPreparedQueriesResponse) GetQueries() []*commonpb.PreparedQuery { @@ -7537,7 +7596,7 @@ type ExecutePreparedQueryRequest struct { func (x *ExecutePreparedQueryRequest) Reset() { *x = ExecutePreparedQueryRequest{} - mi := &file_bucket_proto_msgTypes[111] + mi := &file_bucket_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7549,7 +7608,7 @@ func (x *ExecutePreparedQueryRequest) String() string { func (*ExecutePreparedQueryRequest) ProtoMessage() {} func (x *ExecutePreparedQueryRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[111] + mi := &file_bucket_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7562,7 +7621,7 @@ func (x *ExecutePreparedQueryRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecutePreparedQueryRequest.ProtoReflect.Descriptor instead. func (*ExecutePreparedQueryRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{111} + return file_bucket_proto_rawDescGZIP(), []int{112} } func (x *ExecutePreparedQueryRequest) GetLedger() string { @@ -7627,7 +7686,7 @@ type ExecutePreparedQueryResponse struct { func (x *ExecutePreparedQueryResponse) Reset() { *x = ExecutePreparedQueryResponse{} - mi := &file_bucket_proto_msgTypes[112] + mi := &file_bucket_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7639,7 +7698,7 @@ func (x *ExecutePreparedQueryResponse) String() string { func (*ExecutePreparedQueryResponse) ProtoMessage() {} func (x *ExecutePreparedQueryResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[112] + mi := &file_bucket_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7652,7 +7711,7 @@ func (x *ExecutePreparedQueryResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ExecutePreparedQueryResponse.ProtoReflect.Descriptor instead. func (*ExecutePreparedQueryResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{112} + return file_bucket_proto_rawDescGZIP(), []int{113} } func (x *ExecutePreparedQueryResponse) GetResult() isExecutePreparedQueryResponse_Result { @@ -7710,7 +7769,7 @@ type GetIndexStatusRequest struct { func (x *GetIndexStatusRequest) Reset() { *x = GetIndexStatusRequest{} - mi := &file_bucket_proto_msgTypes[113] + mi := &file_bucket_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7722,7 +7781,7 @@ func (x *GetIndexStatusRequest) String() string { func (*GetIndexStatusRequest) ProtoMessage() {} func (x *GetIndexStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[113] + mi := &file_bucket_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7735,7 +7794,7 @@ func (x *GetIndexStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetIndexStatusRequest.ProtoReflect.Descriptor instead. func (*GetIndexStatusRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{113} + return file_bucket_proto_rawDescGZIP(), []int{114} } func (x *GetIndexStatusRequest) GetLedger() string { @@ -7758,7 +7817,7 @@ type GetIndexStatusResponse struct { func (x *GetIndexStatusResponse) Reset() { *x = GetIndexStatusResponse{} - mi := &file_bucket_proto_msgTypes[114] + mi := &file_bucket_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7770,7 +7829,7 @@ func (x *GetIndexStatusResponse) String() string { func (*GetIndexStatusResponse) ProtoMessage() {} func (x *GetIndexStatusResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[114] + mi := &file_bucket_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7783,7 +7842,7 @@ func (x *GetIndexStatusResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetIndexStatusResponse.ProtoReflect.Descriptor instead. func (*GetIndexStatusResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{114} + return file_bucket_proto_rawDescGZIP(), []int{115} } func (x *GetIndexStatusResponse) GetLastIndexedSequence() uint64 { @@ -7834,7 +7893,7 @@ type GetIndexRequest struct { func (x *GetIndexRequest) Reset() { *x = GetIndexRequest{} - mi := &file_bucket_proto_msgTypes[115] + mi := &file_bucket_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7846,7 +7905,7 @@ func (x *GetIndexRequest) String() string { func (*GetIndexRequest) ProtoMessage() {} func (x *GetIndexRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[115] + mi := &file_bucket_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7859,7 +7918,7 @@ func (x *GetIndexRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetIndexRequest.ProtoReflect.Descriptor instead. func (*GetIndexRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{115} + return file_bucket_proto_rawDescGZIP(), []int{116} } func (x *GetIndexRequest) GetLedger() string { @@ -7889,7 +7948,7 @@ type GetIndexEntryStatusRequest struct { func (x *GetIndexEntryStatusRequest) Reset() { *x = GetIndexEntryStatusRequest{} - mi := &file_bucket_proto_msgTypes[116] + mi := &file_bucket_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7901,7 +7960,7 @@ func (x *GetIndexEntryStatusRequest) String() string { func (*GetIndexEntryStatusRequest) ProtoMessage() {} func (x *GetIndexEntryStatusRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[116] + mi := &file_bucket_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7914,7 +7973,7 @@ func (x *GetIndexEntryStatusRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetIndexEntryStatusRequest.ProtoReflect.Descriptor instead. func (*GetIndexEntryStatusRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{116} + return file_bucket_proto_rawDescGZIP(), []int{117} } func (x *GetIndexEntryStatusRequest) GetLedger() string { @@ -7957,7 +8016,7 @@ type IndexEntry struct { func (x *IndexEntry) Reset() { *x = IndexEntry{} - mi := &file_bucket_proto_msgTypes[117] + mi := &file_bucket_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7969,7 +8028,7 @@ func (x *IndexEntry) String() string { func (*IndexEntry) ProtoMessage() {} func (x *IndexEntry) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[117] + mi := &file_bucket_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7982,7 +8041,7 @@ func (x *IndexEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use IndexEntry.ProtoReflect.Descriptor instead. func (*IndexEntry) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{117} + return file_bucket_proto_rawDescGZIP(), []int{118} } func (x *IndexEntry) GetLedger() string { @@ -8041,7 +8100,7 @@ type ListIndexesRequest struct { func (x *ListIndexesRequest) Reset() { *x = ListIndexesRequest{} - mi := &file_bucket_proto_msgTypes[118] + mi := &file_bucket_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8053,7 +8112,7 @@ func (x *ListIndexesRequest) String() string { func (*ListIndexesRequest) ProtoMessage() {} func (x *ListIndexesRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[118] + mi := &file_bucket_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8066,7 +8125,7 @@ func (x *ListIndexesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListIndexesRequest.ProtoReflect.Descriptor instead. func (*ListIndexesRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{118} + return file_bucket_proto_rawDescGZIP(), []int{119} } func (x *ListIndexesRequest) GetScope() ListIndexesRequest_Scope { @@ -8094,7 +8153,7 @@ type GetLedgerStatsRequest struct { func (x *GetLedgerStatsRequest) Reset() { *x = GetLedgerStatsRequest{} - mi := &file_bucket_proto_msgTypes[119] + mi := &file_bucket_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8106,7 +8165,7 @@ func (x *GetLedgerStatsRequest) String() string { func (*GetLedgerStatsRequest) ProtoMessage() {} func (x *GetLedgerStatsRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[119] + mi := &file_bucket_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8119,7 +8178,7 @@ func (x *GetLedgerStatsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetLedgerStatsRequest.ProtoReflect.Descriptor instead. func (*GetLedgerStatsRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{119} + return file_bucket_proto_rawDescGZIP(), []int{120} } func (x *GetLedgerStatsRequest) GetLedger() string { @@ -8159,7 +8218,7 @@ type AggregateVolumesRequest struct { func (x *AggregateVolumesRequest) Reset() { *x = AggregateVolumesRequest{} - mi := &file_bucket_proto_msgTypes[120] + mi := &file_bucket_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8171,7 +8230,7 @@ func (x *AggregateVolumesRequest) String() string { func (*AggregateVolumesRequest) ProtoMessage() {} func (x *AggregateVolumesRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[120] + mi := &file_bucket_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8184,7 +8243,7 @@ func (x *AggregateVolumesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use AggregateVolumesRequest.ProtoReflect.Descriptor instead. func (*AggregateVolumesRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{120} + return file_bucket_proto_rawDescGZIP(), []int{121} } func (x *AggregateVolumesRequest) GetLedger() string { @@ -8253,7 +8312,7 @@ type QueryProfile struct { func (x *QueryProfile) Reset() { *x = QueryProfile{} - mi := &file_bucket_proto_msgTypes[121] + mi := &file_bucket_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8265,7 +8324,7 @@ func (x *QueryProfile) String() string { func (*QueryProfile) ProtoMessage() {} func (x *QueryProfile) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[121] + mi := &file_bucket_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8278,7 +8337,7 @@ func (x *QueryProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use QueryProfile.ProtoReflect.Descriptor instead. func (*QueryProfile) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{121} + return file_bucket_proto_rawDescGZIP(), []int{122} } func (x *QueryProfile) GetIndexDurationUs() int64 { @@ -8355,7 +8414,7 @@ type IteratorProfile struct { func (x *IteratorProfile) Reset() { *x = IteratorProfile{} - mi := &file_bucket_proto_msgTypes[122] + mi := &file_bucket_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8367,7 +8426,7 @@ func (x *IteratorProfile) String() string { func (*IteratorProfile) ProtoMessage() {} func (x *IteratorProfile) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[122] + mi := &file_bucket_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8380,7 +8439,7 @@ func (x *IteratorProfile) ProtoReflect() protoreflect.Message { // Deprecated: Use IteratorProfile.ProtoReflect.Descriptor instead. func (*IteratorProfile) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{122} + return file_bucket_proto_rawDescGZIP(), []int{123} } func (x *IteratorProfile) GetLabel() string { @@ -8475,7 +8534,7 @@ type InspectIndexRequest struct { func (x *InspectIndexRequest) Reset() { *x = InspectIndexRequest{} - mi := &file_bucket_proto_msgTypes[123] + mi := &file_bucket_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8487,7 +8546,7 @@ func (x *InspectIndexRequest) String() string { func (*InspectIndexRequest) ProtoMessage() {} func (x *InspectIndexRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[123] + mi := &file_bucket_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8500,7 +8559,7 @@ func (x *InspectIndexRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectIndexRequest.ProtoReflect.Descriptor instead. func (*InspectIndexRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{123} + return file_bucket_proto_rawDescGZIP(), []int{124} } func (x *InspectIndexRequest) GetLedger() string { @@ -8566,7 +8625,7 @@ type InspectIndexResponse struct { func (x *InspectIndexResponse) Reset() { *x = InspectIndexResponse{} - mi := &file_bucket_proto_msgTypes[124] + mi := &file_bucket_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8578,7 +8637,7 @@ func (x *InspectIndexResponse) String() string { func (*InspectIndexResponse) ProtoMessage() {} func (x *InspectIndexResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[124] + mi := &file_bucket_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8591,7 +8650,7 @@ func (x *InspectIndexResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectIndexResponse.ProtoReflect.Descriptor instead. func (*InspectIndexResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{124} + return file_bucket_proto_rawDescGZIP(), []int{125} } func (x *InspectIndexResponse) GetResult() isInspectIndexResponse_Result { @@ -8661,7 +8720,7 @@ type InspectDistinctValues struct { func (x *InspectDistinctValues) Reset() { *x = InspectDistinctValues{} - mi := &file_bucket_proto_msgTypes[125] + mi := &file_bucket_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8673,7 +8732,7 @@ func (x *InspectDistinctValues) String() string { func (*InspectDistinctValues) ProtoMessage() {} func (x *InspectDistinctValues) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[125] + mi := &file_bucket_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8686,7 +8745,7 @@ func (x *InspectDistinctValues) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectDistinctValues.ProtoReflect.Descriptor instead. func (*InspectDistinctValues) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{125} + return file_bucket_proto_rawDescGZIP(), []int{126} } func (x *InspectDistinctValues) GetValues() []*commonpb.MetadataValue { @@ -8720,7 +8779,7 @@ type InspectFacet struct { func (x *InspectFacet) Reset() { *x = InspectFacet{} - mi := &file_bucket_proto_msgTypes[126] + mi := &file_bucket_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8732,7 +8791,7 @@ func (x *InspectFacet) String() string { func (*InspectFacet) ProtoMessage() {} func (x *InspectFacet) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[126] + mi := &file_bucket_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8745,7 +8804,7 @@ func (x *InspectFacet) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectFacet.ProtoReflect.Descriptor instead. func (*InspectFacet) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{126} + return file_bucket_proto_rawDescGZIP(), []int{127} } func (x *InspectFacet) GetValue() *commonpb.MetadataValue { @@ -8773,7 +8832,7 @@ type InspectFacets struct { func (x *InspectFacets) Reset() { *x = InspectFacets{} - mi := &file_bucket_proto_msgTypes[127] + mi := &file_bucket_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8785,7 +8844,7 @@ func (x *InspectFacets) String() string { func (*InspectFacets) ProtoMessage() {} func (x *InspectFacets) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[127] + mi := &file_bucket_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8798,7 +8857,7 @@ func (x *InspectFacets) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectFacets.ProtoReflect.Descriptor instead. func (*InspectFacets) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{127} + return file_bucket_proto_rawDescGZIP(), []int{128} } func (x *InspectFacets) GetFacets() []*InspectFacet { @@ -8835,7 +8894,7 @@ type InspectSummary struct { func (x *InspectSummary) Reset() { *x = InspectSummary{} - mi := &file_bucket_proto_msgTypes[128] + mi := &file_bucket_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8847,7 +8906,7 @@ func (x *InspectSummary) String() string { func (*InspectSummary) ProtoMessage() {} func (x *InspectSummary) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[128] + mi := &file_bucket_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8860,7 +8919,7 @@ func (x *InspectSummary) ProtoReflect() protoreflect.Message { // Deprecated: Use InspectSummary.ProtoReflect.Descriptor instead. func (*InspectSummary) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{128} + return file_bucket_proto_rawDescGZIP(), []int{129} } func (x *InspectSummary) GetCardinality() uint64 { @@ -8906,7 +8965,7 @@ type BarrierRequest struct { func (x *BarrierRequest) Reset() { *x = BarrierRequest{} - mi := &file_bucket_proto_msgTypes[129] + mi := &file_bucket_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8918,7 +8977,7 @@ func (x *BarrierRequest) String() string { func (*BarrierRequest) ProtoMessage() {} func (x *BarrierRequest) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[129] + mi := &file_bucket_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8931,7 +8990,7 @@ func (x *BarrierRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use BarrierRequest.ProtoReflect.Descriptor instead. func (*BarrierRequest) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{129} + return file_bucket_proto_rawDescGZIP(), []int{130} } type BarrierResponse struct { @@ -8947,7 +9006,7 @@ type BarrierResponse struct { func (x *BarrierResponse) Reset() { *x = BarrierResponse{} - mi := &file_bucket_proto_msgTypes[130] + mi := &file_bucket_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8959,7 +9018,7 @@ func (x *BarrierResponse) String() string { func (*BarrierResponse) ProtoMessage() {} func (x *BarrierResponse) ProtoReflect() protoreflect.Message { - mi := &file_bucket_proto_msgTypes[130] + mi := &file_bucket_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8972,7 +9031,7 @@ func (x *BarrierResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use BarrierResponse.ProtoReflect.Descriptor instead. func (*BarrierResponse) Descriptor() ([]byte, []int) { - return file_bucket_proto_rawDescGZIP(), []int{130} + return file_bucket_proto_rawDescGZIP(), []int{131} } func (x *BarrierResponse) GetCommitIndex() uint64 { @@ -9051,7 +9110,7 @@ const file_bucket_proto_rawDesc = "" + "\brequests\x18\x01 \x03(\v2\x0f.ledger.RequestR\brequests\x12'\n" + "\x0fidempotency_key\x18\x02 \x01(\tR\x0eidempotencyKey\"0\n" + "\rApplyResponse\x12\x1f\n" + - "\x04logs\x18\x01 \x03(\v2\v.common.LogR\x04logs\"\xe9\x16\n" + + "\x04logs\x18\x01 \x03(\v2\v.common.LogR\x04logs\"\x9c\x16\n" + "\aRequest\x122\n" + "\x05apply\x18\x02 \x01(\v2\x1a.ledger.LedgerApplyRequestH\x00R\x05apply\x12B\n" + "\rcreate_ledger\x18\x03 \x01(\v2\x1b.ledger.CreateLedgerRequestH\x00R\fcreateLedger\x12B\n" + @@ -9078,8 +9137,7 @@ const file_bucket_proto_rawDesc = "" + "\fcreate_index\x18\x19 \x01(\v2\x1a.ledger.CreateIndexRequestH\x00R\vcreateIndex\x129\n" + "\n" + "drop_index\x18\x1a \x01(\v2\x18.ledger.DropIndexRequestH\x00R\tdropIndex\x12E\n" + - "\x0esave_numscript\x18\x1b \x01(\v2\x1c.ledger.SaveNumscriptRequestH\x00R\rsaveNumscript\x12K\n" + - "\x10delete_numscript\x18\x1c \x01(\v2\x1e.ledger.DeleteNumscriptRequestH\x00R\x0fdeleteNumscript\x12O\n" + + "\x0esave_numscript\x18\x1b \x01(\v2\x1c.ledger.SaveNumscriptRequestH\x00R\rsaveNumscript\x12O\n" + "\x10add_account_type\x18\x1d \x01(\v2#.ledger.AddAccountTypeLedgerRequestH\x00R\x0eaddAccountType\x12X\n" + "\x13remove_account_type\x18\x1e \x01(\v2&.ledger.RemoveAccountTypeLedgerRequestH\x00R\x11removeAccountType\x12q\n" + "\x1cset_default_enforcement_mode\x18\x1f \x01(\v2..ledger.SetDefaultEnforcementModeLedgerRequestH\x00R\x19setDefaultEnforcementMode\x12^\n" + @@ -9160,10 +9218,7 @@ const file_bucket_proto_rawDesc = "" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" + "\acontent\x18\x02 \x01(\tR\acontent\x12\x18\n" + "\aversion\x18\x03 \x01(\tR\aversion\x12\x16\n" + - "\x06ledger\x18\x04 \x01(\tR\x06ledger\"D\n" + - "\x16DeleteNumscriptRequest\x12\x12\n" + - "\x04name\x18\x01 \x01(\tR\x04name\x12\x16\n" + - "\x06ledger\x18\x02 \x01(\tR\x06ledger\"\x93\x01\n" + + "\x06ledger\x18\x04 \x01(\tR\x06ledger\"\x93\x01\n" + "\x13GetNumscriptRequest\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\x12\x18\n" + "\aversion\x18\x02 \x01(\tR\aversion\x12\x16\n" + @@ -9171,7 +9226,14 @@ const file_bucket_proto_rawDesc = "" + "\x04read\x18\x04 \x01(\v2\x13.common.ReadOptionsR\x04readR\rcheckpoint_id\"^\n" + "\x15ListNumscriptsRequest\x12\x16\n" + "\x06ledger\x18\x01 \x01(\tR\x06ledger\x12-\n" + - "\aoptions\x18\x02 \x01(\v2\x13.common.ListOptionsR\aoptions\"E\n" + + "\aoptions\x18\x02 \x01(\v2\x13.common.ListOptionsR\aoptions\"s\n" + + "\x1cListNumscriptVersionsRequest\x12\x16\n" + + "\x06ledger\x18\x01 \x01(\tR\x06ledger\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\x12'\n" + + "\x04read\x18\x03 \x01(\v2\x13.common.ReadOptionsR\x04read\"\x81\x01\n" + + "\x1dListNumscriptVersionsResponse\x12%\n" + + "\x0elatest_version\x18\x01 \x01(\tR\rlatestVersion\x129\n" + + "\bversions\x18\x02 \x03(\v2\x1d.common.NumscriptVersionEntryR\bversions\"E\n" + "\x17GetTemplateUsageRequest\x12\x16\n" + "\x06ledger\x18\x01 \x01(\tR\x06ledger\x12\x12\n" + "\x04name\x18\x02 \x01(\tR\x04name\"\xaf\x01\n" + @@ -9619,7 +9681,7 @@ const file_bucket_proto_rawDesc = "" + "\x12entities_with_null\x18\x05 \x01(\x06R\x10entitiesWithNull\"\x10\n" + "\x0eBarrierRequest\"4\n" + "\x0fBarrierResponse\x12!\n" + - "\fcommit_index\x18\x01 \x01(\x06R\vcommitIndex*\xfd\x06\n" + + "\fcommit_index\x18\x01 \x01(\x06R\vcommitIndex*\xac\a\n" + "\x13CheckStoreErrorType\x12&\n" + "\"CHECK_STORE_ERROR_TYPE_UNSPECIFIED\x10\x00\x12(\n" + "$CHECK_STORE_ERROR_TYPE_HASH_MISMATCH\x10\x01\x12'\n" + @@ -9640,7 +9702,8 @@ const file_bucket_proto_rawDesc = "" + "%CHECK_STORE_ERROR_TYPE_MISSING_LEDGER\x10\x0f\x12+\n" + "'CHECK_STORE_ERROR_TYPE_UNAUDITED_LEDGER\x10\x10\x12-\n" + ")CHECK_STORE_ERROR_TYPE_REFERENCE_MISMATCH\x10\x11\x12,\n" + - "(CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH\x10\x12*W\n" + + "(CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH\x10\x12\x12-\n" + + ")CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH\x10\x13*W\n" + "\x12PatternSegmentType\x12\x1e\n" + "\x1aPATTERN_SEGMENT_TYPE_FIXED\x10\x00\x12!\n" + "\x1dPATTERN_SEGMENT_TYPE_VARIABLE\x10\x01*\x9c\x01\n" + @@ -9652,7 +9715,7 @@ const file_bucket_proto_rawDesc = "" + "\x10InspectIndexMode\x12&\n" + "\"INSPECT_INDEX_MODE_DISTINCT_VALUES\x10\x00\x12\x1d\n" + "\x19INSPECT_INDEX_MODE_FACETS\x10\x01\x12\x1e\n" + - "\x1aINSPECT_INDEX_MODE_SUMMARY\x10\x022\xc3\x16\n" + + "\x1aINSPECT_INDEX_MODE_SUMMARY\x10\x022\xa9\x17\n" + "\rBucketService\x12?\n" + "\vListLedgers\x12\x1a.ledger.ListLedgersRequest\x1a\x12.common.LedgerInfo0\x01\x129\n" + "\tGetLedger\x12\x18.ledger.GetLedgerRequest\x1a\x12.common.LedgerInfo\x128\n" + @@ -9691,7 +9754,8 @@ const file_bucket_proto_rawDesc = "" + "\x10AggregateVolumes\x12\x1f.ledger.AggregateVolumesRequest\x1a\x17.common.AggregateResult\x12B\n" + "\fGetNumscript\x12\x1b.ledger.GetNumscriptRequest\x1a\x15.common.NumscriptInfo\x12H\n" + "\x0eListNumscripts\x12\x1d.ledger.ListNumscriptsRequest\x1a\x15.common.NumscriptInfo0\x01\x12J\n" + - "\x10GetTemplateUsage\x12\x1f.ledger.GetTemplateUsageRequest\x1a\x15.common.TemplateUsage\x12I\n" + + "\x10GetTemplateUsage\x12\x1f.ledger.GetTemplateUsageRequest\x1a\x15.common.TemplateUsage\x12d\n" + + "\x15ListNumscriptVersions\x12$.ledger.ListNumscriptVersionsRequest\x1a%.ledger.ListNumscriptVersionsResponse\x12I\n" + "\fInspectIndex\x12\x1b.ledger.InspectIndexRequest\x1a\x1c.ledger.InspectIndexResponse\x12:\n" + "\aBarrier\x12\x16.ledger.BarrierRequest\x1a\x17.ledger.BarrierResponse:p\n" + "\x19allowed_skippable_reasons\x12\x1d.google.protobuf.FieldOptions\x18٪\x04 \x03(\x0e2\x13.common.ErrorReasonR\x17allowedSkippableReasonsB:Z8github.com/formancehq/ledger/v3/internal/proto/servicepbb\x06proto3" @@ -9709,7 +9773,7 @@ func file_bucket_proto_rawDescGZIP() []byte { } var file_bucket_proto_enumTypes = make([]protoimpl.EnumInfo, 5) -var file_bucket_proto_msgTypes = make([]protoimpl.MessageInfo, 141) +var file_bucket_proto_msgTypes = make([]protoimpl.MessageInfo, 142) var file_bucket_proto_goTypes = []any{ (CheckStoreErrorType)(0), // 0: ledger.CheckStoreErrorType (PatternSegmentType)(0), // 1: ledger.PatternSegmentType @@ -9754,167 +9818,169 @@ var file_bucket_proto_goTypes = []any{ (*CreateIndexRequest)(nil), // 40: ledger.CreateIndexRequest (*DropIndexRequest)(nil), // 41: ledger.DropIndexRequest (*SaveNumscriptRequest)(nil), // 42: ledger.SaveNumscriptRequest - (*DeleteNumscriptRequest)(nil), // 43: ledger.DeleteNumscriptRequest - (*GetNumscriptRequest)(nil), // 44: ledger.GetNumscriptRequest - (*ListNumscriptsRequest)(nil), // 45: ledger.ListNumscriptsRequest - (*GetTemplateUsageRequest)(nil), // 46: ledger.GetTemplateUsageRequest - (*ScriptReference)(nil), // 47: ledger.ScriptReference - (*SetQueryCheckpointScheduleRequest)(nil), // 48: ledger.SetQueryCheckpointScheduleRequest - (*DeleteQueryCheckpointScheduleRequest)(nil), // 49: ledger.DeleteQueryCheckpointScheduleRequest - (*GetChapterScheduleRequest)(nil), // 50: ledger.GetChapterScheduleRequest - (*GetChapterScheduleResponse)(nil), // 51: ledger.GetChapterScheduleResponse - (*DiscoveryRequest)(nil), // 52: ledger.DiscoveryRequest - (*ServerInfo)(nil), // 53: ledger.ServerInfo - (*DiscoveryResponse)(nil), // 54: ledger.DiscoveryResponse - (*ResponseSigningInfo)(nil), // 55: ledger.ResponseSigningInfo - (*CreateTransactionPayload)(nil), // 56: ledger.CreateTransactionPayload - (*RevertTransactionPayload)(nil), // 57: ledger.RevertTransactionPayload - (*LedgerAction)(nil), // 58: ledger.LedgerAction - (*LedgerApplyRequest)(nil), // 59: ledger.LedgerApplyRequest - (*AddAccountTypeRequest)(nil), // 60: ledger.AddAccountTypeRequest - (*RemoveAccountTypeRequest)(nil), // 61: ledger.RemoveAccountTypeRequest - (*SetDefaultEnforcementModeRequest)(nil), // 62: ledger.SetDefaultEnforcementModeRequest - (*SetDefaultEnforcementModeLedgerRequest)(nil), // 63: ledger.SetDefaultEnforcementModeLedgerRequest - (*AddAccountTypeLedgerRequest)(nil), // 64: ledger.AddAccountTypeLedgerRequest - (*RemoveAccountTypeLedgerRequest)(nil), // 65: ledger.RemoveAccountTypeLedgerRequest - (*GetPrimaryMetricsRequest)(nil), // 66: ledger.GetPrimaryMetricsRequest - (*GetPrimaryMetricsResponse)(nil), // 67: ledger.GetPrimaryMetricsResponse - (*GetSecondaryMetricsRequest)(nil), // 68: ledger.GetSecondaryMetricsRequest - (*GetSecondaryMetricsResponse)(nil), // 69: ledger.GetSecondaryMetricsResponse - (*PebbleMetrics)(nil), // 70: ledger.PebbleMetrics - (*BlockCacheMetrics)(nil), // 71: ledger.BlockCacheMetrics - (*CompactMetrics)(nil), // 72: ledger.CompactMetrics - (*FlushMetrics)(nil), // 73: ledger.FlushMetrics - (*MemTableMetrics)(nil), // 74: ledger.MemTableMetrics - (*SnapshotsMetrics)(nil), // 75: ledger.SnapshotsMetrics - (*TableMetrics)(nil), // 76: ledger.TableMetrics - (*TableCacheMetrics)(nil), // 77: ledger.TableCacheMetrics - (*WALMetrics)(nil), // 78: ledger.WALMetrics - (*KeysMetrics)(nil), // 79: ledger.KeysMetrics - (*LevelMetrics)(nil), // 80: ledger.LevelMetrics - (*CheckStoreRequest)(nil), // 81: ledger.CheckStoreRequest - (*CheckStoreEvent)(nil), // 82: ledger.CheckStoreEvent - (*CheckStoreError)(nil), // 83: ledger.CheckStoreError - (*CheckStoreProgress)(nil), // 84: ledger.CheckStoreProgress - (*ListAuditEntriesRequest)(nil), // 85: ledger.ListAuditEntriesRequest - (*GetAuditEntryRequest)(nil), // 86: ledger.GetAuditEntryRequest - (*ListLogsRequest)(nil), // 87: ledger.ListLogsRequest - (*GetLogRequest)(nil), // 88: ledger.GetLogRequest - (*GetEventsSinksRequest)(nil), // 89: ledger.GetEventsSinksRequest - (*GetEventsSinksResponse)(nil), // 90: ledger.GetEventsSinksResponse - (*GetMetadataSchemaStatusRequest)(nil), // 91: ledger.GetMetadataSchemaStatusRequest - (*GetMetadataSchemaStatusResponse)(nil), // 92: ledger.GetMetadataSchemaStatusResponse - (*MetadataFieldStatus)(nil), // 93: ledger.MetadataFieldStatus - (*AnalyzeAccountsRequest)(nil), // 94: ledger.AnalyzeAccountsRequest - (*AnalyzeAccountsResponse)(nil), // 95: ledger.AnalyzeAccountsResponse - (*AnalyzeProgress)(nil), // 96: ledger.AnalyzeProgress - (*AnalyzeAccountsEvent)(nil), // 97: ledger.AnalyzeAccountsEvent - (*AnalyzeTransactionsEvent)(nil), // 98: ledger.AnalyzeTransactionsEvent - (*AccountPattern)(nil), // 99: ledger.AccountPattern - (*PatternSegment)(nil), // 100: ledger.PatternSegment - (*AnalyzeTransactionsRequest)(nil), // 101: ledger.AnalyzeTransactionsRequest - (*AnalyzeTransactionsResponse)(nil), // 102: ledger.AnalyzeTransactionsResponse - (*FlowPattern)(nil), // 103: ledger.FlowPattern - (*NormalizedPosting)(nil), // 104: ledger.NormalizedPosting - (*TemporalStats)(nil), // 105: ledger.TemporalStats - (*HourBucket)(nil), // 106: ledger.HourBucket - (*AssetVolumeStats)(nil), // 107: ledger.AssetVolumeStats - (*CreatePreparedQueryRequest)(nil), // 108: ledger.CreatePreparedQueryRequest - (*CreatePreparedQueryResponse)(nil), // 109: ledger.CreatePreparedQueryResponse - (*UpdatePreparedQueryRequest)(nil), // 110: ledger.UpdatePreparedQueryRequest - (*UpdatePreparedQueryResponse)(nil), // 111: ledger.UpdatePreparedQueryResponse - (*DeletePreparedQueryRequest)(nil), // 112: ledger.DeletePreparedQueryRequest - (*DeletePreparedQueryResponse)(nil), // 113: ledger.DeletePreparedQueryResponse - (*ListPreparedQueriesRequest)(nil), // 114: ledger.ListPreparedQueriesRequest - (*ListPreparedQueriesResponse)(nil), // 115: ledger.ListPreparedQueriesResponse - (*ExecutePreparedQueryRequest)(nil), // 116: ledger.ExecutePreparedQueryRequest - (*ExecutePreparedQueryResponse)(nil), // 117: ledger.ExecutePreparedQueryResponse - (*GetIndexStatusRequest)(nil), // 118: ledger.GetIndexStatusRequest - (*GetIndexStatusResponse)(nil), // 119: ledger.GetIndexStatusResponse - (*GetIndexRequest)(nil), // 120: ledger.GetIndexRequest - (*GetIndexEntryStatusRequest)(nil), // 121: ledger.GetIndexEntryStatusRequest - (*IndexEntry)(nil), // 122: ledger.IndexEntry - (*ListIndexesRequest)(nil), // 123: ledger.ListIndexesRequest - (*GetLedgerStatsRequest)(nil), // 124: ledger.GetLedgerStatsRequest - (*AggregateVolumesRequest)(nil), // 125: ledger.AggregateVolumesRequest - (*QueryProfile)(nil), // 126: ledger.QueryProfile - (*IteratorProfile)(nil), // 127: ledger.IteratorProfile - (*InspectIndexRequest)(nil), // 128: ledger.InspectIndexRequest - (*InspectIndexResponse)(nil), // 129: ledger.InspectIndexResponse - (*InspectDistinctValues)(nil), // 130: ledger.InspectDistinctValues - (*InspectFacet)(nil), // 131: ledger.InspectFacet - (*InspectFacets)(nil), // 132: ledger.InspectFacets - (*InspectSummary)(nil), // 133: ledger.InspectSummary - (*BarrierRequest)(nil), // 134: ledger.BarrierRequest - (*BarrierResponse)(nil), // 135: ledger.BarrierResponse - nil, // 136: ledger.CreateLedgerRequest.AccountTypesEntry - nil, // 137: ledger.SaveLedgerMetadataRequest.MetadataEntry - nil, // 138: ledger.ScriptReference.VarsEntry - nil, // 139: ledger.CreateTransactionPayload.MetadataEntry - nil, // 140: ledger.CreateTransactionPayload.AccountMetadataEntry - nil, // 141: ledger.RevertTransactionPayload.MetadataEntry - nil, // 142: ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry - nil, // 143: ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry - nil, // 144: ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry - nil, // 145: ledger.ExecutePreparedQueryRequest.ParametersEntry - (*commonpb.Transaction)(nil), // 146: common.Transaction - (*commonpb.ListOptions)(nil), // 147: common.ListOptions - (*commonpb.SetMetadataFieldTypeCommand)(nil), // 148: common.SetMetadataFieldTypeCommand - (commonpb.LedgerMode)(0), // 149: common.LedgerMode - (*commonpb.MirrorSourceConfig)(nil), // 150: common.MirrorSourceConfig - (commonpb.ChartEnforcementMode)(0), // 151: common.ChartEnforcementMode - (*commonpb.ReadOptions)(nil), // 152: common.ReadOptions - (*signaturepb.SignedApplyBatch)(nil), // 153: signature.SignedApplyBatch - (*commonpb.CallerSnapshot)(nil), // 154: common.CallerSnapshot - (*commonpb.Log)(nil), // 155: common.Log - (*commonpb.SinkConfig)(nil), // 156: common.SinkConfig - (commonpb.TargetType)(0), // 157: common.TargetType - (commonpb.MetadataType)(0), // 158: common.MetadataType - (*commonpb.IndexID)(nil), // 159: common.IndexID - (*commonpb.Posting)(nil), // 160: common.Posting - (*commonpb.Script)(nil), // 161: common.Script - (*commonpb.Timestamp)(nil), // 162: common.Timestamp - (*commonpb.SaveMetadataCommand)(nil), // 163: common.SaveMetadataCommand - (*commonpb.DeleteMetadataCommand)(nil), // 164: common.DeleteMetadataCommand - (commonpb.ErrorReason)(0), // 165: common.ErrorReason - (*commonpb.AccountType)(nil), // 166: common.AccountType - (*commonpb.SinkStatus)(nil), // 167: common.SinkStatus - (*commonpb.PreparedQuery)(nil), // 168: common.PreparedQuery - (*commonpb.QueryFilter)(nil), // 169: common.QueryFilter - (commonpb.QueryMode)(0), // 170: common.QueryMode - (*commonpb.PreparedQueryCursor)(nil), // 171: common.PreparedQueryCursor - (*commonpb.AggregateResult)(nil), // 172: common.AggregateResult - (*commonpb.Index)(nil), // 173: common.Index - (*commonpb.MetadataValue)(nil), // 174: common.MetadataValue - (*commonpb.MetadataMap)(nil), // 175: common.MetadataMap - (*commonpb.ParameterValue)(nil), // 176: common.ParameterValue - (*descriptorpb.FieldOptions)(nil), // 177: google.protobuf.FieldOptions - (*commonpb.LedgerInfo)(nil), // 178: common.LedgerInfo - (*commonpb.Account)(nil), // 179: common.Account - (*auditpb.AuditEntry)(nil), // 180: audit.AuditEntry - (*commonpb.Chapter)(nil), // 181: common.Chapter - (*commonpb.SigningKey)(nil), // 182: common.SigningKey - (*commonpb.LedgerStats)(nil), // 183: common.LedgerStats - (*commonpb.NumscriptInfo)(nil), // 184: common.NumscriptInfo - (*commonpb.TemplateUsage)(nil), // 185: common.TemplateUsage + (*GetNumscriptRequest)(nil), // 43: ledger.GetNumscriptRequest + (*ListNumscriptsRequest)(nil), // 44: ledger.ListNumscriptsRequest + (*ListNumscriptVersionsRequest)(nil), // 45: ledger.ListNumscriptVersionsRequest + (*ListNumscriptVersionsResponse)(nil), // 46: ledger.ListNumscriptVersionsResponse + (*GetTemplateUsageRequest)(nil), // 47: ledger.GetTemplateUsageRequest + (*ScriptReference)(nil), // 48: ledger.ScriptReference + (*SetQueryCheckpointScheduleRequest)(nil), // 49: ledger.SetQueryCheckpointScheduleRequest + (*DeleteQueryCheckpointScheduleRequest)(nil), // 50: ledger.DeleteQueryCheckpointScheduleRequest + (*GetChapterScheduleRequest)(nil), // 51: ledger.GetChapterScheduleRequest + (*GetChapterScheduleResponse)(nil), // 52: ledger.GetChapterScheduleResponse + (*DiscoveryRequest)(nil), // 53: ledger.DiscoveryRequest + (*ServerInfo)(nil), // 54: ledger.ServerInfo + (*DiscoveryResponse)(nil), // 55: ledger.DiscoveryResponse + (*ResponseSigningInfo)(nil), // 56: ledger.ResponseSigningInfo + (*CreateTransactionPayload)(nil), // 57: ledger.CreateTransactionPayload + (*RevertTransactionPayload)(nil), // 58: ledger.RevertTransactionPayload + (*LedgerAction)(nil), // 59: ledger.LedgerAction + (*LedgerApplyRequest)(nil), // 60: ledger.LedgerApplyRequest + (*AddAccountTypeRequest)(nil), // 61: ledger.AddAccountTypeRequest + (*RemoveAccountTypeRequest)(nil), // 62: ledger.RemoveAccountTypeRequest + (*SetDefaultEnforcementModeRequest)(nil), // 63: ledger.SetDefaultEnforcementModeRequest + (*SetDefaultEnforcementModeLedgerRequest)(nil), // 64: ledger.SetDefaultEnforcementModeLedgerRequest + (*AddAccountTypeLedgerRequest)(nil), // 65: ledger.AddAccountTypeLedgerRequest + (*RemoveAccountTypeLedgerRequest)(nil), // 66: ledger.RemoveAccountTypeLedgerRequest + (*GetPrimaryMetricsRequest)(nil), // 67: ledger.GetPrimaryMetricsRequest + (*GetPrimaryMetricsResponse)(nil), // 68: ledger.GetPrimaryMetricsResponse + (*GetSecondaryMetricsRequest)(nil), // 69: ledger.GetSecondaryMetricsRequest + (*GetSecondaryMetricsResponse)(nil), // 70: ledger.GetSecondaryMetricsResponse + (*PebbleMetrics)(nil), // 71: ledger.PebbleMetrics + (*BlockCacheMetrics)(nil), // 72: ledger.BlockCacheMetrics + (*CompactMetrics)(nil), // 73: ledger.CompactMetrics + (*FlushMetrics)(nil), // 74: ledger.FlushMetrics + (*MemTableMetrics)(nil), // 75: ledger.MemTableMetrics + (*SnapshotsMetrics)(nil), // 76: ledger.SnapshotsMetrics + (*TableMetrics)(nil), // 77: ledger.TableMetrics + (*TableCacheMetrics)(nil), // 78: ledger.TableCacheMetrics + (*WALMetrics)(nil), // 79: ledger.WALMetrics + (*KeysMetrics)(nil), // 80: ledger.KeysMetrics + (*LevelMetrics)(nil), // 81: ledger.LevelMetrics + (*CheckStoreRequest)(nil), // 82: ledger.CheckStoreRequest + (*CheckStoreEvent)(nil), // 83: ledger.CheckStoreEvent + (*CheckStoreError)(nil), // 84: ledger.CheckStoreError + (*CheckStoreProgress)(nil), // 85: ledger.CheckStoreProgress + (*ListAuditEntriesRequest)(nil), // 86: ledger.ListAuditEntriesRequest + (*GetAuditEntryRequest)(nil), // 87: ledger.GetAuditEntryRequest + (*ListLogsRequest)(nil), // 88: ledger.ListLogsRequest + (*GetLogRequest)(nil), // 89: ledger.GetLogRequest + (*GetEventsSinksRequest)(nil), // 90: ledger.GetEventsSinksRequest + (*GetEventsSinksResponse)(nil), // 91: ledger.GetEventsSinksResponse + (*GetMetadataSchemaStatusRequest)(nil), // 92: ledger.GetMetadataSchemaStatusRequest + (*GetMetadataSchemaStatusResponse)(nil), // 93: ledger.GetMetadataSchemaStatusResponse + (*MetadataFieldStatus)(nil), // 94: ledger.MetadataFieldStatus + (*AnalyzeAccountsRequest)(nil), // 95: ledger.AnalyzeAccountsRequest + (*AnalyzeAccountsResponse)(nil), // 96: ledger.AnalyzeAccountsResponse + (*AnalyzeProgress)(nil), // 97: ledger.AnalyzeProgress + (*AnalyzeAccountsEvent)(nil), // 98: ledger.AnalyzeAccountsEvent + (*AnalyzeTransactionsEvent)(nil), // 99: ledger.AnalyzeTransactionsEvent + (*AccountPattern)(nil), // 100: ledger.AccountPattern + (*PatternSegment)(nil), // 101: ledger.PatternSegment + (*AnalyzeTransactionsRequest)(nil), // 102: ledger.AnalyzeTransactionsRequest + (*AnalyzeTransactionsResponse)(nil), // 103: ledger.AnalyzeTransactionsResponse + (*FlowPattern)(nil), // 104: ledger.FlowPattern + (*NormalizedPosting)(nil), // 105: ledger.NormalizedPosting + (*TemporalStats)(nil), // 106: ledger.TemporalStats + (*HourBucket)(nil), // 107: ledger.HourBucket + (*AssetVolumeStats)(nil), // 108: ledger.AssetVolumeStats + (*CreatePreparedQueryRequest)(nil), // 109: ledger.CreatePreparedQueryRequest + (*CreatePreparedQueryResponse)(nil), // 110: ledger.CreatePreparedQueryResponse + (*UpdatePreparedQueryRequest)(nil), // 111: ledger.UpdatePreparedQueryRequest + (*UpdatePreparedQueryResponse)(nil), // 112: ledger.UpdatePreparedQueryResponse + (*DeletePreparedQueryRequest)(nil), // 113: ledger.DeletePreparedQueryRequest + (*DeletePreparedQueryResponse)(nil), // 114: ledger.DeletePreparedQueryResponse + (*ListPreparedQueriesRequest)(nil), // 115: ledger.ListPreparedQueriesRequest + (*ListPreparedQueriesResponse)(nil), // 116: ledger.ListPreparedQueriesResponse + (*ExecutePreparedQueryRequest)(nil), // 117: ledger.ExecutePreparedQueryRequest + (*ExecutePreparedQueryResponse)(nil), // 118: ledger.ExecutePreparedQueryResponse + (*GetIndexStatusRequest)(nil), // 119: ledger.GetIndexStatusRequest + (*GetIndexStatusResponse)(nil), // 120: ledger.GetIndexStatusResponse + (*GetIndexRequest)(nil), // 121: ledger.GetIndexRequest + (*GetIndexEntryStatusRequest)(nil), // 122: ledger.GetIndexEntryStatusRequest + (*IndexEntry)(nil), // 123: ledger.IndexEntry + (*ListIndexesRequest)(nil), // 124: ledger.ListIndexesRequest + (*GetLedgerStatsRequest)(nil), // 125: ledger.GetLedgerStatsRequest + (*AggregateVolumesRequest)(nil), // 126: ledger.AggregateVolumesRequest + (*QueryProfile)(nil), // 127: ledger.QueryProfile + (*IteratorProfile)(nil), // 128: ledger.IteratorProfile + (*InspectIndexRequest)(nil), // 129: ledger.InspectIndexRequest + (*InspectIndexResponse)(nil), // 130: ledger.InspectIndexResponse + (*InspectDistinctValues)(nil), // 131: ledger.InspectDistinctValues + (*InspectFacet)(nil), // 132: ledger.InspectFacet + (*InspectFacets)(nil), // 133: ledger.InspectFacets + (*InspectSummary)(nil), // 134: ledger.InspectSummary + (*BarrierRequest)(nil), // 135: ledger.BarrierRequest + (*BarrierResponse)(nil), // 136: ledger.BarrierResponse + nil, // 137: ledger.CreateLedgerRequest.AccountTypesEntry + nil, // 138: ledger.SaveLedgerMetadataRequest.MetadataEntry + nil, // 139: ledger.ScriptReference.VarsEntry + nil, // 140: ledger.CreateTransactionPayload.MetadataEntry + nil, // 141: ledger.CreateTransactionPayload.AccountMetadataEntry + nil, // 142: ledger.RevertTransactionPayload.MetadataEntry + nil, // 143: ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry + nil, // 144: ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry + nil, // 145: ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry + nil, // 146: ledger.ExecutePreparedQueryRequest.ParametersEntry + (*commonpb.Transaction)(nil), // 147: common.Transaction + (*commonpb.ListOptions)(nil), // 148: common.ListOptions + (*commonpb.SetMetadataFieldTypeCommand)(nil), // 149: common.SetMetadataFieldTypeCommand + (commonpb.LedgerMode)(0), // 150: common.LedgerMode + (*commonpb.MirrorSourceConfig)(nil), // 151: common.MirrorSourceConfig + (commonpb.ChartEnforcementMode)(0), // 152: common.ChartEnforcementMode + (*commonpb.ReadOptions)(nil), // 153: common.ReadOptions + (*signaturepb.SignedApplyBatch)(nil), // 154: signature.SignedApplyBatch + (*commonpb.CallerSnapshot)(nil), // 155: common.CallerSnapshot + (*commonpb.Log)(nil), // 156: common.Log + (*commonpb.SinkConfig)(nil), // 157: common.SinkConfig + (commonpb.TargetType)(0), // 158: common.TargetType + (commonpb.MetadataType)(0), // 159: common.MetadataType + (*commonpb.IndexID)(nil), // 160: common.IndexID + (*commonpb.NumscriptVersionEntry)(nil), // 161: common.NumscriptVersionEntry + (*commonpb.Posting)(nil), // 162: common.Posting + (*commonpb.Script)(nil), // 163: common.Script + (*commonpb.Timestamp)(nil), // 164: common.Timestamp + (*commonpb.SaveMetadataCommand)(nil), // 165: common.SaveMetadataCommand + (*commonpb.DeleteMetadataCommand)(nil), // 166: common.DeleteMetadataCommand + (commonpb.ErrorReason)(0), // 167: common.ErrorReason + (*commonpb.AccountType)(nil), // 168: common.AccountType + (*commonpb.SinkStatus)(nil), // 169: common.SinkStatus + (*commonpb.PreparedQuery)(nil), // 170: common.PreparedQuery + (*commonpb.QueryFilter)(nil), // 171: common.QueryFilter + (commonpb.QueryMode)(0), // 172: common.QueryMode + (*commonpb.PreparedQueryCursor)(nil), // 173: common.PreparedQueryCursor + (*commonpb.AggregateResult)(nil), // 174: common.AggregateResult + (*commonpb.Index)(nil), // 175: common.Index + (*commonpb.MetadataValue)(nil), // 176: common.MetadataValue + (*commonpb.MetadataMap)(nil), // 177: common.MetadataMap + (*commonpb.ParameterValue)(nil), // 178: common.ParameterValue + (*descriptorpb.FieldOptions)(nil), // 179: google.protobuf.FieldOptions + (*commonpb.LedgerInfo)(nil), // 180: common.LedgerInfo + (*commonpb.Account)(nil), // 181: common.Account + (*auditpb.AuditEntry)(nil), // 182: audit.AuditEntry + (*commonpb.Chapter)(nil), // 183: common.Chapter + (*commonpb.SigningKey)(nil), // 184: common.SigningKey + (*commonpb.LedgerStats)(nil), // 185: common.LedgerStats + (*commonpb.NumscriptInfo)(nil), // 186: common.NumscriptInfo + (*commonpb.TemplateUsage)(nil), // 187: common.TemplateUsage } var file_bucket_proto_depIdxs = []int32{ - 146, // 0: ledger.GetTransactionResponse.transaction:type_name -> common.Transaction - 147, // 1: ledger.ListTransactionsRequest.options:type_name -> common.ListOptions - 147, // 2: ledger.ListAccountsRequest.options:type_name -> common.ListOptions - 148, // 3: ledger.CreateLedgerRequest.initial_schema:type_name -> common.SetMetadataFieldTypeCommand - 149, // 4: ledger.CreateLedgerRequest.mode:type_name -> common.LedgerMode - 150, // 5: ledger.CreateLedgerRequest.mirror_source:type_name -> common.MirrorSourceConfig - 136, // 6: ledger.CreateLedgerRequest.account_types:type_name -> ledger.CreateLedgerRequest.AccountTypesEntry - 151, // 7: ledger.CreateLedgerRequest.default_enforcement_mode:type_name -> common.ChartEnforcementMode - 147, // 8: ledger.ListLedgersRequest.options:type_name -> common.ListOptions - 152, // 9: ledger.GetLedgerRequest.read:type_name -> common.ReadOptions + 147, // 0: ledger.GetTransactionResponse.transaction:type_name -> common.Transaction + 148, // 1: ledger.ListTransactionsRequest.options:type_name -> common.ListOptions + 148, // 2: ledger.ListAccountsRequest.options:type_name -> common.ListOptions + 149, // 3: ledger.CreateLedgerRequest.initial_schema:type_name -> common.SetMetadataFieldTypeCommand + 150, // 4: ledger.CreateLedgerRequest.mode:type_name -> common.LedgerMode + 151, // 5: ledger.CreateLedgerRequest.mirror_source:type_name -> common.MirrorSourceConfig + 137, // 6: ledger.CreateLedgerRequest.account_types:type_name -> ledger.CreateLedgerRequest.AccountTypesEntry + 152, // 7: ledger.CreateLedgerRequest.default_enforcement_mode:type_name -> common.ChartEnforcementMode + 148, // 8: ledger.ListLedgersRequest.options:type_name -> common.ListOptions + 153, // 9: ledger.GetLedgerRequest.read:type_name -> common.ReadOptions 16, // 10: ledger.ApplyRequest.unsigned:type_name -> ledger.ApplyBatch - 153, // 11: ledger.ApplyRequest.signed:type_name -> signature.SignedApplyBatch - 154, // 12: ledger.ApplyRequest.forwarded_caller_snapshot:type_name -> common.CallerSnapshot + 154, // 11: ledger.ApplyRequest.signed:type_name -> signature.SignedApplyBatch + 155, // 12: ledger.ApplyRequest.forwarded_caller_snapshot:type_name -> common.CallerSnapshot 18, // 13: ledger.ApplyBatch.requests:type_name -> ledger.Request - 155, // 14: ledger.ApplyResponse.logs:type_name -> common.Log - 59, // 15: ledger.Request.apply:type_name -> ledger.LedgerApplyRequest + 156, // 14: ledger.ApplyResponse.logs:type_name -> common.Log + 60, // 15: ledger.Request.apply:type_name -> ledger.LedgerApplyRequest 10, // 16: ledger.Request.create_ledger:type_name -> ledger.CreateLedgerRequest 11, // 17: ledger.Request.delete_ledger:type_name -> ledger.DeleteLedgerRequest 26, // 18: ledger.Request.register_signing_key:type_name -> ledger.RegisterSigningKeyRequest @@ -9932,211 +9998,214 @@ var file_bucket_proto_depIdxs = []int32{ 38, // 30: ledger.Request.set_metadata_field_type:type_name -> ledger.SetMetadataFieldTypeRequest 39, // 31: ledger.Request.remove_metadata_field_type:type_name -> ledger.RemoveMetadataFieldTypeRequest 21, // 32: ledger.Request.promote_ledger:type_name -> ledger.PromoteLedgerRequest - 108, // 33: ledger.Request.create_prepared_query:type_name -> ledger.CreatePreparedQueryRequest - 110, // 34: ledger.Request.update_prepared_query:type_name -> ledger.UpdatePreparedQueryRequest - 112, // 35: ledger.Request.delete_prepared_query:type_name -> ledger.DeletePreparedQueryRequest + 109, // 33: ledger.Request.create_prepared_query:type_name -> ledger.CreatePreparedQueryRequest + 111, // 34: ledger.Request.update_prepared_query:type_name -> ledger.UpdatePreparedQueryRequest + 113, // 35: ledger.Request.delete_prepared_query:type_name -> ledger.DeletePreparedQueryRequest 40, // 36: ledger.Request.create_index:type_name -> ledger.CreateIndexRequest 41, // 37: ledger.Request.drop_index:type_name -> ledger.DropIndexRequest 42, // 38: ledger.Request.save_numscript:type_name -> ledger.SaveNumscriptRequest - 43, // 39: ledger.Request.delete_numscript:type_name -> ledger.DeleteNumscriptRequest - 64, // 40: ledger.Request.add_account_type:type_name -> ledger.AddAccountTypeLedgerRequest - 65, // 41: ledger.Request.remove_account_type:type_name -> ledger.RemoveAccountTypeLedgerRequest - 63, // 42: ledger.Request.set_default_enforcement_mode:type_name -> ledger.SetDefaultEnforcementModeLedgerRequest - 19, // 43: ledger.Request.create_query_checkpoint:type_name -> ledger.CreateQueryCheckpointRequest - 20, // 44: ledger.Request.delete_query_checkpoint:type_name -> ledger.DeleteQueryCheckpointRequest - 48, // 45: ledger.Request.set_query_checkpoint_schedule:type_name -> ledger.SetQueryCheckpointScheduleRequest - 49, // 46: ledger.Request.delete_query_checkpoint_schedule:type_name -> ledger.DeleteQueryCheckpointScheduleRequest - 22, // 47: ledger.Request.save_ledger_metadata:type_name -> ledger.SaveLedgerMetadataRequest - 23, // 48: ledger.Request.delete_ledger_metadata:type_name -> ledger.DeleteLedgerMetadataRequest - 137, // 49: ledger.SaveLedgerMetadataRequest.metadata:type_name -> ledger.SaveLedgerMetadataRequest.MetadataEntry - 156, // 50: ledger.AddEventsSinkRequest.config:type_name -> common.SinkConfig - 147, // 51: ledger.ListSigningKeysRequest.options:type_name -> common.ListOptions - 147, // 52: ledger.ListChaptersRequest.options:type_name -> common.ListOptions - 157, // 53: ledger.SetMetadataFieldTypeRequest.target_type:type_name -> common.TargetType - 158, // 54: ledger.SetMetadataFieldTypeRequest.type:type_name -> common.MetadataType - 157, // 55: ledger.RemoveMetadataFieldTypeRequest.target_type:type_name -> common.TargetType - 159, // 56: ledger.CreateIndexRequest.id:type_name -> common.IndexID - 159, // 57: ledger.DropIndexRequest.id:type_name -> common.IndexID - 152, // 58: ledger.GetNumscriptRequest.read:type_name -> common.ReadOptions - 147, // 59: ledger.ListNumscriptsRequest.options:type_name -> common.ListOptions - 138, // 60: ledger.ScriptReference.vars:type_name -> ledger.ScriptReference.VarsEntry - 55, // 61: ledger.DiscoveryResponse.response_signing:type_name -> ledger.ResponseSigningInfo - 53, // 62: ledger.DiscoveryResponse.server_info:type_name -> ledger.ServerInfo - 160, // 63: ledger.CreateTransactionPayload.postings:type_name -> common.Posting - 161, // 64: ledger.CreateTransactionPayload.script:type_name -> common.Script - 162, // 65: ledger.CreateTransactionPayload.timestamp:type_name -> common.Timestamp - 139, // 66: ledger.CreateTransactionPayload.metadata:type_name -> ledger.CreateTransactionPayload.MetadataEntry - 140, // 67: ledger.CreateTransactionPayload.account_metadata:type_name -> ledger.CreateTransactionPayload.AccountMetadataEntry - 47, // 68: ledger.CreateTransactionPayload.script_reference:type_name -> ledger.ScriptReference - 141, // 69: ledger.RevertTransactionPayload.metadata:type_name -> ledger.RevertTransactionPayload.MetadataEntry - 56, // 70: ledger.LedgerAction.create_transaction:type_name -> ledger.CreateTransactionPayload - 163, // 71: ledger.LedgerAction.add_metadata:type_name -> common.SaveMetadataCommand - 57, // 72: ledger.LedgerAction.revert_transaction:type_name -> ledger.RevertTransactionPayload - 164, // 73: ledger.LedgerAction.delete_metadata:type_name -> common.DeleteMetadataCommand - 60, // 74: ledger.LedgerAction.add_account_type:type_name -> ledger.AddAccountTypeRequest - 61, // 75: ledger.LedgerAction.remove_account_type:type_name -> ledger.RemoveAccountTypeRequest - 62, // 76: ledger.LedgerAction.set_default_enforcement_mode:type_name -> ledger.SetDefaultEnforcementModeRequest - 58, // 77: ledger.LedgerApplyRequest.action:type_name -> ledger.LedgerAction - 165, // 78: ledger.LedgerApplyRequest.skippable_reasons:type_name -> common.ErrorReason - 166, // 79: ledger.AddAccountTypeRequest.account_type:type_name -> common.AccountType - 151, // 80: ledger.SetDefaultEnforcementModeRequest.enforcement_mode:type_name -> common.ChartEnforcementMode - 151, // 81: ledger.SetDefaultEnforcementModeLedgerRequest.enforcement_mode:type_name -> common.ChartEnforcementMode - 166, // 82: ledger.AddAccountTypeLedgerRequest.account_type:type_name -> common.AccountType - 70, // 83: ledger.GetPrimaryMetricsResponse.metrics:type_name -> ledger.PebbleMetrics - 70, // 84: ledger.GetSecondaryMetricsResponse.metrics:type_name -> ledger.PebbleMetrics - 71, // 85: ledger.PebbleMetrics.block_cache:type_name -> ledger.BlockCacheMetrics - 72, // 86: ledger.PebbleMetrics.compact:type_name -> ledger.CompactMetrics - 73, // 87: ledger.PebbleMetrics.flush:type_name -> ledger.FlushMetrics - 74, // 88: ledger.PebbleMetrics.mem_table:type_name -> ledger.MemTableMetrics - 75, // 89: ledger.PebbleMetrics.snapshots:type_name -> ledger.SnapshotsMetrics - 76, // 90: ledger.PebbleMetrics.table:type_name -> ledger.TableMetrics - 77, // 91: ledger.PebbleMetrics.table_cache:type_name -> ledger.TableCacheMetrics - 78, // 92: ledger.PebbleMetrics.wal:type_name -> ledger.WALMetrics - 79, // 93: ledger.PebbleMetrics.keys:type_name -> ledger.KeysMetrics - 80, // 94: ledger.PebbleMetrics.levels:type_name -> ledger.LevelMetrics - 83, // 95: ledger.CheckStoreEvent.error:type_name -> ledger.CheckStoreError - 84, // 96: ledger.CheckStoreEvent.progress:type_name -> ledger.CheckStoreProgress - 0, // 97: ledger.CheckStoreError.error_type:type_name -> ledger.CheckStoreErrorType - 147, // 98: ledger.ListAuditEntriesRequest.options:type_name -> common.ListOptions - 147, // 99: ledger.ListLogsRequest.options:type_name -> common.ListOptions - 156, // 100: ledger.GetEventsSinksResponse.sinks:type_name -> common.SinkConfig - 167, // 101: ledger.GetEventsSinksResponse.sink_statuses:type_name -> common.SinkStatus - 142, // 102: ledger.GetMetadataSchemaStatusResponse.account_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry - 143, // 103: ledger.GetMetadataSchemaStatusResponse.transaction_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry - 144, // 104: ledger.GetMetadataSchemaStatusResponse.ledger_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry - 158, // 105: ledger.MetadataFieldStatus.declared_type:type_name -> common.MetadataType - 99, // 106: ledger.AnalyzeAccountsResponse.patterns:type_name -> ledger.AccountPattern - 96, // 107: ledger.AnalyzeAccountsEvent.progress:type_name -> ledger.AnalyzeProgress - 95, // 108: ledger.AnalyzeAccountsEvent.result:type_name -> ledger.AnalyzeAccountsResponse - 96, // 109: ledger.AnalyzeTransactionsEvent.progress:type_name -> ledger.AnalyzeProgress - 102, // 110: ledger.AnalyzeTransactionsEvent.result:type_name -> ledger.AnalyzeTransactionsResponse - 100, // 111: ledger.AccountPattern.segments:type_name -> ledger.PatternSegment - 1, // 112: ledger.PatternSegment.type:type_name -> ledger.PatternSegmentType - 103, // 113: ledger.AnalyzeTransactionsResponse.flow_patterns:type_name -> ledger.FlowPattern - 2, // 114: ledger.FlowPattern.structure:type_name -> ledger.PostingStructure - 104, // 115: ledger.FlowPattern.postings:type_name -> ledger.NormalizedPosting - 105, // 116: ledger.FlowPattern.temporal:type_name -> ledger.TemporalStats - 107, // 117: ledger.FlowPattern.volume_stats:type_name -> ledger.AssetVolumeStats - 162, // 118: ledger.TemporalStats.first_seen:type_name -> common.Timestamp - 162, // 119: ledger.TemporalStats.last_seen:type_name -> common.Timestamp - 106, // 120: ledger.TemporalStats.peak_hours:type_name -> ledger.HourBucket - 168, // 121: ledger.CreatePreparedQueryRequest.query:type_name -> common.PreparedQuery - 169, // 122: ledger.UpdatePreparedQueryRequest.filter:type_name -> common.QueryFilter - 168, // 123: ledger.ListPreparedQueriesResponse.queries:type_name -> common.PreparedQuery - 145, // 124: ledger.ExecutePreparedQueryRequest.parameters:type_name -> ledger.ExecutePreparedQueryRequest.ParametersEntry - 170, // 125: ledger.ExecutePreparedQueryRequest.mode:type_name -> common.QueryMode - 171, // 126: ledger.ExecutePreparedQueryResponse.cursor:type_name -> common.PreparedQueryCursor - 172, // 127: ledger.ExecutePreparedQueryResponse.aggregate:type_name -> common.AggregateResult - 122, // 128: ledger.GetIndexStatusResponse.indexes:type_name -> ledger.IndexEntry - 159, // 129: ledger.GetIndexRequest.id:type_name -> common.IndexID - 159, // 130: ledger.GetIndexEntryStatusRequest.id:type_name -> common.IndexID - 173, // 131: ledger.IndexEntry.index:type_name -> common.Index - 4, // 132: ledger.ListIndexesRequest.scope:type_name -> ledger.ListIndexesRequest.Scope - 169, // 133: ledger.AggregateVolumesRequest.filter:type_name -> common.QueryFilter - 127, // 134: ledger.QueryProfile.root_iterator:type_name -> ledger.IteratorProfile - 127, // 135: ledger.IteratorProfile.children:type_name -> ledger.IteratorProfile - 157, // 136: ledger.InspectIndexRequest.target_type:type_name -> common.TargetType - 3, // 137: ledger.InspectIndexRequest.mode:type_name -> ledger.InspectIndexMode - 130, // 138: ledger.InspectIndexResponse.distinct_values:type_name -> ledger.InspectDistinctValues - 132, // 139: ledger.InspectIndexResponse.facets:type_name -> ledger.InspectFacets - 133, // 140: ledger.InspectIndexResponse.summary:type_name -> ledger.InspectSummary - 174, // 141: ledger.InspectDistinctValues.values:type_name -> common.MetadataValue - 174, // 142: ledger.InspectFacet.value:type_name -> common.MetadataValue - 131, // 143: ledger.InspectFacets.facets:type_name -> ledger.InspectFacet - 174, // 144: ledger.InspectSummary.min:type_name -> common.MetadataValue - 174, // 145: ledger.InspectSummary.max:type_name -> common.MetadataValue - 166, // 146: ledger.CreateLedgerRequest.AccountTypesEntry.value:type_name -> common.AccountType - 174, // 147: ledger.SaveLedgerMetadataRequest.MetadataEntry.value:type_name -> common.MetadataValue - 174, // 148: ledger.CreateTransactionPayload.MetadataEntry.value:type_name -> common.MetadataValue - 175, // 149: ledger.CreateTransactionPayload.AccountMetadataEntry.value:type_name -> common.MetadataMap - 174, // 150: ledger.RevertTransactionPayload.MetadataEntry.value:type_name -> common.MetadataValue - 93, // 151: ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry.value:type_name -> ledger.MetadataFieldStatus - 93, // 152: ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry.value:type_name -> ledger.MetadataFieldStatus - 93, // 153: ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry.value:type_name -> ledger.MetadataFieldStatus - 176, // 154: ledger.ExecutePreparedQueryRequest.ParametersEntry.value:type_name -> common.ParameterValue - 177, // 155: ledger.allowed_skippable_reasons:extendee -> google.protobuf.FieldOptions - 165, // 156: ledger.allowed_skippable_reasons:type_name -> common.ErrorReason - 13, // 157: ledger.BucketService.ListLedgers:input_type -> ledger.ListLedgersRequest - 14, // 158: ledger.BucketService.GetLedger:input_type -> ledger.GetLedgerRequest - 5, // 159: ledger.BucketService.GetAccount:input_type -> ledger.GetAccountRequest - 6, // 160: ledger.BucketService.GetTransaction:input_type -> ledger.GetTransactionRequest - 8, // 161: ledger.BucketService.ListTransactions:input_type -> ledger.ListTransactionsRequest - 9, // 162: ledger.BucketService.ListAccounts:input_type -> ledger.ListAccountsRequest - 15, // 163: ledger.BucketService.Apply:input_type -> ledger.ApplyRequest - 66, // 164: ledger.BucketService.GetPrimaryMetrics:input_type -> ledger.GetPrimaryMetricsRequest - 68, // 165: ledger.BucketService.GetSecondaryMetrics:input_type -> ledger.GetSecondaryMetricsRequest - 81, // 166: ledger.BucketService.CheckStore:input_type -> ledger.CheckStoreRequest - 85, // 167: ledger.BucketService.ListAuditEntries:input_type -> ledger.ListAuditEntriesRequest - 86, // 168: ledger.BucketService.GetAuditEntry:input_type -> ledger.GetAuditEntryRequest - 89, // 169: ledger.BucketService.GetEventsSinks:input_type -> ledger.GetEventsSinksRequest - 34, // 170: ledger.BucketService.ListChapters:input_type -> ledger.ListChaptersRequest - 87, // 171: ledger.BucketService.ListLogs:input_type -> ledger.ListLogsRequest - 88, // 172: ledger.BucketService.GetLog:input_type -> ledger.GetLogRequest - 50, // 173: ledger.BucketService.GetChapterSchedule:input_type -> ledger.GetChapterScheduleRequest - 29, // 174: ledger.BucketService.ListSigningKeys:input_type -> ledger.ListSigningKeysRequest - 52, // 175: ledger.BucketService.Discovery:input_type -> ledger.DiscoveryRequest - 91, // 176: ledger.BucketService.GetMetadataSchemaStatus:input_type -> ledger.GetMetadataSchemaStatusRequest - 94, // 177: ledger.BucketService.AnalyzeAccounts:input_type -> ledger.AnalyzeAccountsRequest - 101, // 178: ledger.BucketService.AnalyzeTransactions:input_type -> ledger.AnalyzeTransactionsRequest - 108, // 179: ledger.BucketService.CreatePreparedQuery:input_type -> ledger.CreatePreparedQueryRequest - 110, // 180: ledger.BucketService.UpdatePreparedQuery:input_type -> ledger.UpdatePreparedQueryRequest - 112, // 181: ledger.BucketService.DeletePreparedQuery:input_type -> ledger.DeletePreparedQueryRequest - 114, // 182: ledger.BucketService.ListPreparedQueries:input_type -> ledger.ListPreparedQueriesRequest - 116, // 183: ledger.BucketService.ExecutePreparedQuery:input_type -> ledger.ExecutePreparedQueryRequest - 118, // 184: ledger.BucketService.GetIndexStatus:input_type -> ledger.GetIndexStatusRequest - 120, // 185: ledger.BucketService.GetIndex:input_type -> ledger.GetIndexRequest - 121, // 186: ledger.BucketService.GetIndexEntryStatus:input_type -> ledger.GetIndexEntryStatusRequest - 123, // 187: ledger.BucketService.ListIndexes:input_type -> ledger.ListIndexesRequest - 124, // 188: ledger.BucketService.GetLedgerStats:input_type -> ledger.GetLedgerStatsRequest - 125, // 189: ledger.BucketService.AggregateVolumes:input_type -> ledger.AggregateVolumesRequest - 44, // 190: ledger.BucketService.GetNumscript:input_type -> ledger.GetNumscriptRequest - 45, // 191: ledger.BucketService.ListNumscripts:input_type -> ledger.ListNumscriptsRequest - 46, // 192: ledger.BucketService.GetTemplateUsage:input_type -> ledger.GetTemplateUsageRequest - 128, // 193: ledger.BucketService.InspectIndex:input_type -> ledger.InspectIndexRequest - 134, // 194: ledger.BucketService.Barrier:input_type -> ledger.BarrierRequest - 178, // 195: ledger.BucketService.ListLedgers:output_type -> common.LedgerInfo - 178, // 196: ledger.BucketService.GetLedger:output_type -> common.LedgerInfo - 179, // 197: ledger.BucketService.GetAccount:output_type -> common.Account - 7, // 198: ledger.BucketService.GetTransaction:output_type -> ledger.GetTransactionResponse - 146, // 199: ledger.BucketService.ListTransactions:output_type -> common.Transaction - 179, // 200: ledger.BucketService.ListAccounts:output_type -> common.Account - 17, // 201: ledger.BucketService.Apply:output_type -> ledger.ApplyResponse - 67, // 202: ledger.BucketService.GetPrimaryMetrics:output_type -> ledger.GetPrimaryMetricsResponse - 69, // 203: ledger.BucketService.GetSecondaryMetrics:output_type -> ledger.GetSecondaryMetricsResponse - 82, // 204: ledger.BucketService.CheckStore:output_type -> ledger.CheckStoreEvent - 180, // 205: ledger.BucketService.ListAuditEntries:output_type -> audit.AuditEntry - 180, // 206: ledger.BucketService.GetAuditEntry:output_type -> audit.AuditEntry - 90, // 207: ledger.BucketService.GetEventsSinks:output_type -> ledger.GetEventsSinksResponse - 181, // 208: ledger.BucketService.ListChapters:output_type -> common.Chapter - 155, // 209: ledger.BucketService.ListLogs:output_type -> common.Log - 155, // 210: ledger.BucketService.GetLog:output_type -> common.Log - 51, // 211: ledger.BucketService.GetChapterSchedule:output_type -> ledger.GetChapterScheduleResponse - 182, // 212: ledger.BucketService.ListSigningKeys:output_type -> common.SigningKey - 54, // 213: ledger.BucketService.Discovery:output_type -> ledger.DiscoveryResponse - 92, // 214: ledger.BucketService.GetMetadataSchemaStatus:output_type -> ledger.GetMetadataSchemaStatusResponse - 97, // 215: ledger.BucketService.AnalyzeAccounts:output_type -> ledger.AnalyzeAccountsEvent - 98, // 216: ledger.BucketService.AnalyzeTransactions:output_type -> ledger.AnalyzeTransactionsEvent - 109, // 217: ledger.BucketService.CreatePreparedQuery:output_type -> ledger.CreatePreparedQueryResponse - 111, // 218: ledger.BucketService.UpdatePreparedQuery:output_type -> ledger.UpdatePreparedQueryResponse - 113, // 219: ledger.BucketService.DeletePreparedQuery:output_type -> ledger.DeletePreparedQueryResponse - 115, // 220: ledger.BucketService.ListPreparedQueries:output_type -> ledger.ListPreparedQueriesResponse - 117, // 221: ledger.BucketService.ExecutePreparedQuery:output_type -> ledger.ExecutePreparedQueryResponse - 119, // 222: ledger.BucketService.GetIndexStatus:output_type -> ledger.GetIndexStatusResponse - 173, // 223: ledger.BucketService.GetIndex:output_type -> common.Index - 122, // 224: ledger.BucketService.GetIndexEntryStatus:output_type -> ledger.IndexEntry - 173, // 225: ledger.BucketService.ListIndexes:output_type -> common.Index - 183, // 226: ledger.BucketService.GetLedgerStats:output_type -> common.LedgerStats - 172, // 227: ledger.BucketService.AggregateVolumes:output_type -> common.AggregateResult - 184, // 228: ledger.BucketService.GetNumscript:output_type -> common.NumscriptInfo - 184, // 229: ledger.BucketService.ListNumscripts:output_type -> common.NumscriptInfo - 185, // 230: ledger.BucketService.GetTemplateUsage:output_type -> common.TemplateUsage - 129, // 231: ledger.BucketService.InspectIndex:output_type -> ledger.InspectIndexResponse - 135, // 232: ledger.BucketService.Barrier:output_type -> ledger.BarrierResponse - 195, // [195:233] is the sub-list for method output_type - 157, // [157:195] is the sub-list for method input_type - 156, // [156:157] is the sub-list for extension type_name - 155, // [155:156] is the sub-list for extension extendee - 0, // [0:155] is the sub-list for field type_name + 65, // 39: ledger.Request.add_account_type:type_name -> ledger.AddAccountTypeLedgerRequest + 66, // 40: ledger.Request.remove_account_type:type_name -> ledger.RemoveAccountTypeLedgerRequest + 64, // 41: ledger.Request.set_default_enforcement_mode:type_name -> ledger.SetDefaultEnforcementModeLedgerRequest + 19, // 42: ledger.Request.create_query_checkpoint:type_name -> ledger.CreateQueryCheckpointRequest + 20, // 43: ledger.Request.delete_query_checkpoint:type_name -> ledger.DeleteQueryCheckpointRequest + 49, // 44: ledger.Request.set_query_checkpoint_schedule:type_name -> ledger.SetQueryCheckpointScheduleRequest + 50, // 45: ledger.Request.delete_query_checkpoint_schedule:type_name -> ledger.DeleteQueryCheckpointScheduleRequest + 22, // 46: ledger.Request.save_ledger_metadata:type_name -> ledger.SaveLedgerMetadataRequest + 23, // 47: ledger.Request.delete_ledger_metadata:type_name -> ledger.DeleteLedgerMetadataRequest + 138, // 48: ledger.SaveLedgerMetadataRequest.metadata:type_name -> ledger.SaveLedgerMetadataRequest.MetadataEntry + 157, // 49: ledger.AddEventsSinkRequest.config:type_name -> common.SinkConfig + 148, // 50: ledger.ListSigningKeysRequest.options:type_name -> common.ListOptions + 148, // 51: ledger.ListChaptersRequest.options:type_name -> common.ListOptions + 158, // 52: ledger.SetMetadataFieldTypeRequest.target_type:type_name -> common.TargetType + 159, // 53: ledger.SetMetadataFieldTypeRequest.type:type_name -> common.MetadataType + 158, // 54: ledger.RemoveMetadataFieldTypeRequest.target_type:type_name -> common.TargetType + 160, // 55: ledger.CreateIndexRequest.id:type_name -> common.IndexID + 160, // 56: ledger.DropIndexRequest.id:type_name -> common.IndexID + 153, // 57: ledger.GetNumscriptRequest.read:type_name -> common.ReadOptions + 148, // 58: ledger.ListNumscriptsRequest.options:type_name -> common.ListOptions + 153, // 59: ledger.ListNumscriptVersionsRequest.read:type_name -> common.ReadOptions + 161, // 60: ledger.ListNumscriptVersionsResponse.versions:type_name -> common.NumscriptVersionEntry + 139, // 61: ledger.ScriptReference.vars:type_name -> ledger.ScriptReference.VarsEntry + 56, // 62: ledger.DiscoveryResponse.response_signing:type_name -> ledger.ResponseSigningInfo + 54, // 63: ledger.DiscoveryResponse.server_info:type_name -> ledger.ServerInfo + 162, // 64: ledger.CreateTransactionPayload.postings:type_name -> common.Posting + 163, // 65: ledger.CreateTransactionPayload.script:type_name -> common.Script + 164, // 66: ledger.CreateTransactionPayload.timestamp:type_name -> common.Timestamp + 140, // 67: ledger.CreateTransactionPayload.metadata:type_name -> ledger.CreateTransactionPayload.MetadataEntry + 141, // 68: ledger.CreateTransactionPayload.account_metadata:type_name -> ledger.CreateTransactionPayload.AccountMetadataEntry + 48, // 69: ledger.CreateTransactionPayload.script_reference:type_name -> ledger.ScriptReference + 142, // 70: ledger.RevertTransactionPayload.metadata:type_name -> ledger.RevertTransactionPayload.MetadataEntry + 57, // 71: ledger.LedgerAction.create_transaction:type_name -> ledger.CreateTransactionPayload + 165, // 72: ledger.LedgerAction.add_metadata:type_name -> common.SaveMetadataCommand + 58, // 73: ledger.LedgerAction.revert_transaction:type_name -> ledger.RevertTransactionPayload + 166, // 74: ledger.LedgerAction.delete_metadata:type_name -> common.DeleteMetadataCommand + 61, // 75: ledger.LedgerAction.add_account_type:type_name -> ledger.AddAccountTypeRequest + 62, // 76: ledger.LedgerAction.remove_account_type:type_name -> ledger.RemoveAccountTypeRequest + 63, // 77: ledger.LedgerAction.set_default_enforcement_mode:type_name -> ledger.SetDefaultEnforcementModeRequest + 59, // 78: ledger.LedgerApplyRequest.action:type_name -> ledger.LedgerAction + 167, // 79: ledger.LedgerApplyRequest.skippable_reasons:type_name -> common.ErrorReason + 168, // 80: ledger.AddAccountTypeRequest.account_type:type_name -> common.AccountType + 152, // 81: ledger.SetDefaultEnforcementModeRequest.enforcement_mode:type_name -> common.ChartEnforcementMode + 152, // 82: ledger.SetDefaultEnforcementModeLedgerRequest.enforcement_mode:type_name -> common.ChartEnforcementMode + 168, // 83: ledger.AddAccountTypeLedgerRequest.account_type:type_name -> common.AccountType + 71, // 84: ledger.GetPrimaryMetricsResponse.metrics:type_name -> ledger.PebbleMetrics + 71, // 85: ledger.GetSecondaryMetricsResponse.metrics:type_name -> ledger.PebbleMetrics + 72, // 86: ledger.PebbleMetrics.block_cache:type_name -> ledger.BlockCacheMetrics + 73, // 87: ledger.PebbleMetrics.compact:type_name -> ledger.CompactMetrics + 74, // 88: ledger.PebbleMetrics.flush:type_name -> ledger.FlushMetrics + 75, // 89: ledger.PebbleMetrics.mem_table:type_name -> ledger.MemTableMetrics + 76, // 90: ledger.PebbleMetrics.snapshots:type_name -> ledger.SnapshotsMetrics + 77, // 91: ledger.PebbleMetrics.table:type_name -> ledger.TableMetrics + 78, // 92: ledger.PebbleMetrics.table_cache:type_name -> ledger.TableCacheMetrics + 79, // 93: ledger.PebbleMetrics.wal:type_name -> ledger.WALMetrics + 80, // 94: ledger.PebbleMetrics.keys:type_name -> ledger.KeysMetrics + 81, // 95: ledger.PebbleMetrics.levels:type_name -> ledger.LevelMetrics + 84, // 96: ledger.CheckStoreEvent.error:type_name -> ledger.CheckStoreError + 85, // 97: ledger.CheckStoreEvent.progress:type_name -> ledger.CheckStoreProgress + 0, // 98: ledger.CheckStoreError.error_type:type_name -> ledger.CheckStoreErrorType + 148, // 99: ledger.ListAuditEntriesRequest.options:type_name -> common.ListOptions + 148, // 100: ledger.ListLogsRequest.options:type_name -> common.ListOptions + 157, // 101: ledger.GetEventsSinksResponse.sinks:type_name -> common.SinkConfig + 169, // 102: ledger.GetEventsSinksResponse.sink_statuses:type_name -> common.SinkStatus + 143, // 103: ledger.GetMetadataSchemaStatusResponse.account_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry + 144, // 104: ledger.GetMetadataSchemaStatusResponse.transaction_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry + 145, // 105: ledger.GetMetadataSchemaStatusResponse.ledger_fields:type_name -> ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry + 159, // 106: ledger.MetadataFieldStatus.declared_type:type_name -> common.MetadataType + 100, // 107: ledger.AnalyzeAccountsResponse.patterns:type_name -> ledger.AccountPattern + 97, // 108: ledger.AnalyzeAccountsEvent.progress:type_name -> ledger.AnalyzeProgress + 96, // 109: ledger.AnalyzeAccountsEvent.result:type_name -> ledger.AnalyzeAccountsResponse + 97, // 110: ledger.AnalyzeTransactionsEvent.progress:type_name -> ledger.AnalyzeProgress + 103, // 111: ledger.AnalyzeTransactionsEvent.result:type_name -> ledger.AnalyzeTransactionsResponse + 101, // 112: ledger.AccountPattern.segments:type_name -> ledger.PatternSegment + 1, // 113: ledger.PatternSegment.type:type_name -> ledger.PatternSegmentType + 104, // 114: ledger.AnalyzeTransactionsResponse.flow_patterns:type_name -> ledger.FlowPattern + 2, // 115: ledger.FlowPattern.structure:type_name -> ledger.PostingStructure + 105, // 116: ledger.FlowPattern.postings:type_name -> ledger.NormalizedPosting + 106, // 117: ledger.FlowPattern.temporal:type_name -> ledger.TemporalStats + 108, // 118: ledger.FlowPattern.volume_stats:type_name -> ledger.AssetVolumeStats + 164, // 119: ledger.TemporalStats.first_seen:type_name -> common.Timestamp + 164, // 120: ledger.TemporalStats.last_seen:type_name -> common.Timestamp + 107, // 121: ledger.TemporalStats.peak_hours:type_name -> ledger.HourBucket + 170, // 122: ledger.CreatePreparedQueryRequest.query:type_name -> common.PreparedQuery + 171, // 123: ledger.UpdatePreparedQueryRequest.filter:type_name -> common.QueryFilter + 170, // 124: ledger.ListPreparedQueriesResponse.queries:type_name -> common.PreparedQuery + 146, // 125: ledger.ExecutePreparedQueryRequest.parameters:type_name -> ledger.ExecutePreparedQueryRequest.ParametersEntry + 172, // 126: ledger.ExecutePreparedQueryRequest.mode:type_name -> common.QueryMode + 173, // 127: ledger.ExecutePreparedQueryResponse.cursor:type_name -> common.PreparedQueryCursor + 174, // 128: ledger.ExecutePreparedQueryResponse.aggregate:type_name -> common.AggregateResult + 123, // 129: ledger.GetIndexStatusResponse.indexes:type_name -> ledger.IndexEntry + 160, // 130: ledger.GetIndexRequest.id:type_name -> common.IndexID + 160, // 131: ledger.GetIndexEntryStatusRequest.id:type_name -> common.IndexID + 175, // 132: ledger.IndexEntry.index:type_name -> common.Index + 4, // 133: ledger.ListIndexesRequest.scope:type_name -> ledger.ListIndexesRequest.Scope + 171, // 134: ledger.AggregateVolumesRequest.filter:type_name -> common.QueryFilter + 128, // 135: ledger.QueryProfile.root_iterator:type_name -> ledger.IteratorProfile + 128, // 136: ledger.IteratorProfile.children:type_name -> ledger.IteratorProfile + 158, // 137: ledger.InspectIndexRequest.target_type:type_name -> common.TargetType + 3, // 138: ledger.InspectIndexRequest.mode:type_name -> ledger.InspectIndexMode + 131, // 139: ledger.InspectIndexResponse.distinct_values:type_name -> ledger.InspectDistinctValues + 133, // 140: ledger.InspectIndexResponse.facets:type_name -> ledger.InspectFacets + 134, // 141: ledger.InspectIndexResponse.summary:type_name -> ledger.InspectSummary + 176, // 142: ledger.InspectDistinctValues.values:type_name -> common.MetadataValue + 176, // 143: ledger.InspectFacet.value:type_name -> common.MetadataValue + 132, // 144: ledger.InspectFacets.facets:type_name -> ledger.InspectFacet + 176, // 145: ledger.InspectSummary.min:type_name -> common.MetadataValue + 176, // 146: ledger.InspectSummary.max:type_name -> common.MetadataValue + 168, // 147: ledger.CreateLedgerRequest.AccountTypesEntry.value:type_name -> common.AccountType + 176, // 148: ledger.SaveLedgerMetadataRequest.MetadataEntry.value:type_name -> common.MetadataValue + 176, // 149: ledger.CreateTransactionPayload.MetadataEntry.value:type_name -> common.MetadataValue + 177, // 150: ledger.CreateTransactionPayload.AccountMetadataEntry.value:type_name -> common.MetadataMap + 176, // 151: ledger.RevertTransactionPayload.MetadataEntry.value:type_name -> common.MetadataValue + 94, // 152: ledger.GetMetadataSchemaStatusResponse.AccountFieldsEntry.value:type_name -> ledger.MetadataFieldStatus + 94, // 153: ledger.GetMetadataSchemaStatusResponse.TransactionFieldsEntry.value:type_name -> ledger.MetadataFieldStatus + 94, // 154: ledger.GetMetadataSchemaStatusResponse.LedgerFieldsEntry.value:type_name -> ledger.MetadataFieldStatus + 178, // 155: ledger.ExecutePreparedQueryRequest.ParametersEntry.value:type_name -> common.ParameterValue + 179, // 156: ledger.allowed_skippable_reasons:extendee -> google.protobuf.FieldOptions + 167, // 157: ledger.allowed_skippable_reasons:type_name -> common.ErrorReason + 13, // 158: ledger.BucketService.ListLedgers:input_type -> ledger.ListLedgersRequest + 14, // 159: ledger.BucketService.GetLedger:input_type -> ledger.GetLedgerRequest + 5, // 160: ledger.BucketService.GetAccount:input_type -> ledger.GetAccountRequest + 6, // 161: ledger.BucketService.GetTransaction:input_type -> ledger.GetTransactionRequest + 8, // 162: ledger.BucketService.ListTransactions:input_type -> ledger.ListTransactionsRequest + 9, // 163: ledger.BucketService.ListAccounts:input_type -> ledger.ListAccountsRequest + 15, // 164: ledger.BucketService.Apply:input_type -> ledger.ApplyRequest + 67, // 165: ledger.BucketService.GetPrimaryMetrics:input_type -> ledger.GetPrimaryMetricsRequest + 69, // 166: ledger.BucketService.GetSecondaryMetrics:input_type -> ledger.GetSecondaryMetricsRequest + 82, // 167: ledger.BucketService.CheckStore:input_type -> ledger.CheckStoreRequest + 86, // 168: ledger.BucketService.ListAuditEntries:input_type -> ledger.ListAuditEntriesRequest + 87, // 169: ledger.BucketService.GetAuditEntry:input_type -> ledger.GetAuditEntryRequest + 90, // 170: ledger.BucketService.GetEventsSinks:input_type -> ledger.GetEventsSinksRequest + 34, // 171: ledger.BucketService.ListChapters:input_type -> ledger.ListChaptersRequest + 88, // 172: ledger.BucketService.ListLogs:input_type -> ledger.ListLogsRequest + 89, // 173: ledger.BucketService.GetLog:input_type -> ledger.GetLogRequest + 51, // 174: ledger.BucketService.GetChapterSchedule:input_type -> ledger.GetChapterScheduleRequest + 29, // 175: ledger.BucketService.ListSigningKeys:input_type -> ledger.ListSigningKeysRequest + 53, // 176: ledger.BucketService.Discovery:input_type -> ledger.DiscoveryRequest + 92, // 177: ledger.BucketService.GetMetadataSchemaStatus:input_type -> ledger.GetMetadataSchemaStatusRequest + 95, // 178: ledger.BucketService.AnalyzeAccounts:input_type -> ledger.AnalyzeAccountsRequest + 102, // 179: ledger.BucketService.AnalyzeTransactions:input_type -> ledger.AnalyzeTransactionsRequest + 109, // 180: ledger.BucketService.CreatePreparedQuery:input_type -> ledger.CreatePreparedQueryRequest + 111, // 181: ledger.BucketService.UpdatePreparedQuery:input_type -> ledger.UpdatePreparedQueryRequest + 113, // 182: ledger.BucketService.DeletePreparedQuery:input_type -> ledger.DeletePreparedQueryRequest + 115, // 183: ledger.BucketService.ListPreparedQueries:input_type -> ledger.ListPreparedQueriesRequest + 117, // 184: ledger.BucketService.ExecutePreparedQuery:input_type -> ledger.ExecutePreparedQueryRequest + 119, // 185: ledger.BucketService.GetIndexStatus:input_type -> ledger.GetIndexStatusRequest + 121, // 186: ledger.BucketService.GetIndex:input_type -> ledger.GetIndexRequest + 122, // 187: ledger.BucketService.GetIndexEntryStatus:input_type -> ledger.GetIndexEntryStatusRequest + 124, // 188: ledger.BucketService.ListIndexes:input_type -> ledger.ListIndexesRequest + 125, // 189: ledger.BucketService.GetLedgerStats:input_type -> ledger.GetLedgerStatsRequest + 126, // 190: ledger.BucketService.AggregateVolumes:input_type -> ledger.AggregateVolumesRequest + 43, // 191: ledger.BucketService.GetNumscript:input_type -> ledger.GetNumscriptRequest + 44, // 192: ledger.BucketService.ListNumscripts:input_type -> ledger.ListNumscriptsRequest + 47, // 193: ledger.BucketService.GetTemplateUsage:input_type -> ledger.GetTemplateUsageRequest + 45, // 194: ledger.BucketService.ListNumscriptVersions:input_type -> ledger.ListNumscriptVersionsRequest + 129, // 195: ledger.BucketService.InspectIndex:input_type -> ledger.InspectIndexRequest + 135, // 196: ledger.BucketService.Barrier:input_type -> ledger.BarrierRequest + 180, // 197: ledger.BucketService.ListLedgers:output_type -> common.LedgerInfo + 180, // 198: ledger.BucketService.GetLedger:output_type -> common.LedgerInfo + 181, // 199: ledger.BucketService.GetAccount:output_type -> common.Account + 7, // 200: ledger.BucketService.GetTransaction:output_type -> ledger.GetTransactionResponse + 147, // 201: ledger.BucketService.ListTransactions:output_type -> common.Transaction + 181, // 202: ledger.BucketService.ListAccounts:output_type -> common.Account + 17, // 203: ledger.BucketService.Apply:output_type -> ledger.ApplyResponse + 68, // 204: ledger.BucketService.GetPrimaryMetrics:output_type -> ledger.GetPrimaryMetricsResponse + 70, // 205: ledger.BucketService.GetSecondaryMetrics:output_type -> ledger.GetSecondaryMetricsResponse + 83, // 206: ledger.BucketService.CheckStore:output_type -> ledger.CheckStoreEvent + 182, // 207: ledger.BucketService.ListAuditEntries:output_type -> audit.AuditEntry + 182, // 208: ledger.BucketService.GetAuditEntry:output_type -> audit.AuditEntry + 91, // 209: ledger.BucketService.GetEventsSinks:output_type -> ledger.GetEventsSinksResponse + 183, // 210: ledger.BucketService.ListChapters:output_type -> common.Chapter + 156, // 211: ledger.BucketService.ListLogs:output_type -> common.Log + 156, // 212: ledger.BucketService.GetLog:output_type -> common.Log + 52, // 213: ledger.BucketService.GetChapterSchedule:output_type -> ledger.GetChapterScheduleResponse + 184, // 214: ledger.BucketService.ListSigningKeys:output_type -> common.SigningKey + 55, // 215: ledger.BucketService.Discovery:output_type -> ledger.DiscoveryResponse + 93, // 216: ledger.BucketService.GetMetadataSchemaStatus:output_type -> ledger.GetMetadataSchemaStatusResponse + 98, // 217: ledger.BucketService.AnalyzeAccounts:output_type -> ledger.AnalyzeAccountsEvent + 99, // 218: ledger.BucketService.AnalyzeTransactions:output_type -> ledger.AnalyzeTransactionsEvent + 110, // 219: ledger.BucketService.CreatePreparedQuery:output_type -> ledger.CreatePreparedQueryResponse + 112, // 220: ledger.BucketService.UpdatePreparedQuery:output_type -> ledger.UpdatePreparedQueryResponse + 114, // 221: ledger.BucketService.DeletePreparedQuery:output_type -> ledger.DeletePreparedQueryResponse + 116, // 222: ledger.BucketService.ListPreparedQueries:output_type -> ledger.ListPreparedQueriesResponse + 118, // 223: ledger.BucketService.ExecutePreparedQuery:output_type -> ledger.ExecutePreparedQueryResponse + 120, // 224: ledger.BucketService.GetIndexStatus:output_type -> ledger.GetIndexStatusResponse + 175, // 225: ledger.BucketService.GetIndex:output_type -> common.Index + 123, // 226: ledger.BucketService.GetIndexEntryStatus:output_type -> ledger.IndexEntry + 175, // 227: ledger.BucketService.ListIndexes:output_type -> common.Index + 185, // 228: ledger.BucketService.GetLedgerStats:output_type -> common.LedgerStats + 174, // 229: ledger.BucketService.AggregateVolumes:output_type -> common.AggregateResult + 186, // 230: ledger.BucketService.GetNumscript:output_type -> common.NumscriptInfo + 186, // 231: ledger.BucketService.ListNumscripts:output_type -> common.NumscriptInfo + 187, // 232: ledger.BucketService.GetTemplateUsage:output_type -> common.TemplateUsage + 46, // 233: ledger.BucketService.ListNumscriptVersions:output_type -> ledger.ListNumscriptVersionsResponse + 130, // 234: ledger.BucketService.InspectIndex:output_type -> ledger.InspectIndexResponse + 136, // 235: ledger.BucketService.Barrier:output_type -> ledger.BarrierResponse + 197, // [197:236] is the sub-list for method output_type + 158, // [158:197] is the sub-list for method input_type + 157, // [157:158] is the sub-list for extension type_name + 156, // [156:157] is the sub-list for extension extendee + 0, // [0:156] is the sub-list for field type_name } func init() { file_bucket_proto_init() } @@ -10173,7 +10242,6 @@ func file_bucket_proto_init() { (*Request_CreateIndex)(nil), (*Request_DropIndex)(nil), (*Request_SaveNumscript)(nil), - (*Request_DeleteNumscript)(nil), (*Request_AddAccountType)(nil), (*Request_RemoveAccountType)(nil), (*Request_SetDefaultEnforcementMode)(nil), @@ -10184,7 +10252,7 @@ func file_bucket_proto_init() { (*Request_SaveLedgerMetadata)(nil), (*Request_DeleteLedgerMetadata)(nil), } - file_bucket_proto_msgTypes[53].OneofWrappers = []any{ + file_bucket_proto_msgTypes[54].OneofWrappers = []any{ (*LedgerAction_CreateTransaction)(nil), (*LedgerAction_AddMetadata)(nil), (*LedgerAction_RevertTransaction)(nil), @@ -10193,23 +10261,23 @@ func file_bucket_proto_init() { (*LedgerAction_RemoveAccountType)(nil), (*LedgerAction_SetDefaultEnforcementMode)(nil), } - file_bucket_proto_msgTypes[77].OneofWrappers = []any{ + file_bucket_proto_msgTypes[78].OneofWrappers = []any{ (*CheckStoreEvent_Error)(nil), (*CheckStoreEvent_Progress)(nil), } - file_bucket_proto_msgTypes[92].OneofWrappers = []any{ + file_bucket_proto_msgTypes[93].OneofWrappers = []any{ (*AnalyzeAccountsEvent_Progress)(nil), (*AnalyzeAccountsEvent_Result)(nil), } - file_bucket_proto_msgTypes[93].OneofWrappers = []any{ + file_bucket_proto_msgTypes[94].OneofWrappers = []any{ (*AnalyzeTransactionsEvent_Progress)(nil), (*AnalyzeTransactionsEvent_Result)(nil), } - file_bucket_proto_msgTypes[112].OneofWrappers = []any{ + file_bucket_proto_msgTypes[113].OneofWrappers = []any{ (*ExecutePreparedQueryResponse_Cursor)(nil), (*ExecutePreparedQueryResponse_Aggregate)(nil), } - file_bucket_proto_msgTypes[124].OneofWrappers = []any{ + file_bucket_proto_msgTypes[125].OneofWrappers = []any{ (*InspectIndexResponse_DistinctValues)(nil), (*InspectIndexResponse_Facets)(nil), (*InspectIndexResponse_Summary)(nil), @@ -10220,7 +10288,7 @@ func file_bucket_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_bucket_proto_rawDesc), len(file_bucket_proto_rawDesc)), NumEnums: 5, - NumMessages: 141, + NumMessages: 142, NumExtensions: 1, NumServices: 1, }, diff --git a/internal/proto/servicepb/bucket_dethash.pb.go b/internal/proto/servicepb/bucket_dethash.pb.go index b9e4aec0da..48a734a7a5 100644 --- a/internal/proto/servicepb/bucket_dethash.pb.go +++ b/internal/proto/servicepb/bucket_dethash.pb.go @@ -589,16 +589,6 @@ func (m *Request) MarshalToSizedBufferDeterministicVT(dAtA []byte) (int, error) i-- dAtA[i] = 0xda } - case *Request_DeleteNumscript: - if v.DeleteNumscript != nil { - size, _ := v.DeleteNumscript.MarshalToSizedBufferVT(dAtA[:i]) - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xe2 - } case *Request_AddAccountType: if v.AddAccountType != nil { size, _ := v.AddAccountType.MarshalToSizedBufferDeterministicVT(dAtA[:i]) @@ -1003,7 +993,7 @@ func (m *SaveNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { return append(dAtA, b...) } -func (m *DeleteNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { +func (m *GetNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { if m == nil { return dAtA } @@ -1014,7 +1004,7 @@ func (m *DeleteNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { return append(dAtA, b...) } -func (m *GetNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { +func (m *ListNumscriptsRequest) MarshalDeterministicVT(dAtA []byte) []byte { if m == nil { return dAtA } @@ -1025,7 +1015,18 @@ func (m *GetNumscriptRequest) MarshalDeterministicVT(dAtA []byte) []byte { return append(dAtA, b...) } -func (m *ListNumscriptsRequest) MarshalDeterministicVT(dAtA []byte) []byte { +func (m *ListNumscriptVersionsRequest) MarshalDeterministicVT(dAtA []byte) []byte { + if m == nil { + return dAtA + } + b, err := m.MarshalVT() + if err != nil { + panic("MarshalDeterministicVT: " + err.Error()) + } + return append(dAtA, b...) +} + +func (m *ListNumscriptVersionsResponse) MarshalDeterministicVT(dAtA []byte) []byte { if m == nil { return dAtA } diff --git a/internal/proto/servicepb/bucket_grpc.pb.go b/internal/proto/servicepb/bucket_grpc.pb.go index f78240c3cd..b5757848eb 100644 --- a/internal/proto/servicepb/bucket_grpc.pb.go +++ b/internal/proto/servicepb/bucket_grpc.pb.go @@ -57,6 +57,7 @@ const ( BucketService_GetNumscript_FullMethodName = "/ledger.BucketService/GetNumscript" BucketService_ListNumscripts_FullMethodName = "/ledger.BucketService/ListNumscripts" BucketService_GetTemplateUsage_FullMethodName = "/ledger.BucketService/GetTemplateUsage" + BucketService_ListNumscriptVersions_FullMethodName = "/ledger.BucketService/ListNumscriptVersions" BucketService_InspectIndex_FullMethodName = "/ledger.BucketService/InspectIndex" BucketService_Barrier_FullMethodName = "/ledger.BucketService/Barrier" ) @@ -143,6 +144,9 @@ type BucketServiceClient interface { // usagebuilder subsystem. Eventually consistent — may lag the live FSM // by up to one usagebuilder tick interval. GetTemplateUsage(ctx context.Context, in *GetTemplateUsageRequest, opts ...grpc.CallOption) (*commonpb.TemplateUsage, error) + // ListNumscriptVersions returns the latest pointer and every stored version + // of a numscript, ordered greatest semver first. + ListNumscriptVersions(ctx context.Context, in *ListNumscriptVersionsRequest, opts ...grpc.CallOption) (*ListNumscriptVersionsResponse, error) // InspectIndex scans a metadata index and returns distinct values, facets, or a summary InspectIndex(ctx context.Context, in *InspectIndexRequest, opts ...grpc.CallOption) (*InspectIndexResponse, error) // Barrier proposes a no-op through Raft consensus. When it returns, all @@ -627,6 +631,16 @@ func (c *bucketServiceClient) GetTemplateUsage(ctx context.Context, in *GetTempl return out, nil } +func (c *bucketServiceClient) ListNumscriptVersions(ctx context.Context, in *ListNumscriptVersionsRequest, opts ...grpc.CallOption) (*ListNumscriptVersionsResponse, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(ListNumscriptVersionsResponse) + err := c.cc.Invoke(ctx, BucketService_ListNumscriptVersions_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *bucketServiceClient) InspectIndex(ctx context.Context, in *InspectIndexRequest, opts ...grpc.CallOption) (*InspectIndexResponse, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(InspectIndexResponse) @@ -729,6 +743,9 @@ type BucketServiceServer interface { // usagebuilder subsystem. Eventually consistent — may lag the live FSM // by up to one usagebuilder tick interval. GetTemplateUsage(context.Context, *GetTemplateUsageRequest) (*commonpb.TemplateUsage, error) + // ListNumscriptVersions returns the latest pointer and every stored version + // of a numscript, ordered greatest semver first. + ListNumscriptVersions(context.Context, *ListNumscriptVersionsRequest) (*ListNumscriptVersionsResponse, error) // InspectIndex scans a metadata index and returns distinct values, facets, or a summary InspectIndex(context.Context, *InspectIndexRequest) (*InspectIndexResponse, error) // Barrier proposes a no-op through Raft consensus. When it returns, all @@ -853,6 +870,9 @@ func (UnimplementedBucketServiceServer) ListNumscripts(*ListNumscriptsRequest, g func (UnimplementedBucketServiceServer) GetTemplateUsage(context.Context, *GetTemplateUsageRequest) (*commonpb.TemplateUsage, error) { return nil, status.Error(codes.Unimplemented, "method GetTemplateUsage not implemented") } +func (UnimplementedBucketServiceServer) ListNumscriptVersions(context.Context, *ListNumscriptVersionsRequest) (*ListNumscriptVersionsResponse, error) { + return nil, status.Error(codes.Unimplemented, "method ListNumscriptVersions not implemented") +} func (UnimplementedBucketServiceServer) InspectIndex(context.Context, *InspectIndexRequest) (*InspectIndexResponse, error) { return nil, status.Error(codes.Unimplemented, "method InspectIndex not implemented") } @@ -1444,6 +1464,24 @@ func _BucketService_GetTemplateUsage_Handler(srv interface{}, ctx context.Contex return interceptor(ctx, in, info, handler) } +func _BucketService_ListNumscriptVersions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(ListNumscriptVersionsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(BucketServiceServer).ListNumscriptVersions(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: BucketService_ListNumscriptVersions_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(BucketServiceServer).ListNumscriptVersions(ctx, req.(*ListNumscriptVersionsRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _BucketService_InspectIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(InspectIndexRequest) if err := dec(in); err != nil { @@ -1583,6 +1621,10 @@ var BucketService_ServiceDesc = grpc.ServiceDesc{ MethodName: "GetTemplateUsage", Handler: _BucketService_GetTemplateUsage_Handler, }, + { + MethodName: "ListNumscriptVersions", + Handler: _BucketService_ListNumscriptVersions_Handler, + }, { MethodName: "InspectIndex", Handler: _BucketService_InspectIndex_Handler, diff --git a/internal/proto/servicepb/bucket_reader.pb.go b/internal/proto/servicepb/bucket_reader.pb.go index 9f88b4174a..e844f8841b 100644 --- a/internal/proto/servicepb/bucket_reader.pb.go +++ b/internal/proto/servicepb/bucket_reader.pb.go @@ -2806,78 +2806,6 @@ func NewSaveNumscriptRequestListReader(s []*SaveNumscriptRequest) SaveNumscriptR return saveNumscriptRequestListReadonly(s) } -// DeleteNumscriptRequestReader provides read-only access to DeleteNumscriptRequest. -// Call Mutate() to obtain a mutable clone. -type DeleteNumscriptRequestReader interface { - GetName() string - GetLedger() string - Mutate() *DeleteNumscriptRequest -} - -type deleteNumscriptRequestReadonly DeleteNumscriptRequest - -func (r *deleteNumscriptRequestReadonly) GetName() string { - return (*DeleteNumscriptRequest)(r).GetName() -} - -func (r *deleteNumscriptRequestReadonly) GetLedger() string { - return (*DeleteNumscriptRequest)(r).GetLedger() -} - -func (r *deleteNumscriptRequestReadonly) Mutate() *DeleteNumscriptRequest { - return (*DeleteNumscriptRequest)(r).CloneVT() -} - -// AsReader returns a read-only view of this DeleteNumscriptRequest. -func (m *DeleteNumscriptRequest) AsReader() DeleteNumscriptRequestReader { - if m == nil { - return nil - } - return (*deleteNumscriptRequestReadonly)(m) -} - -// Mutate returns a mutable deep clone of this DeleteNumscriptRequest. -func (m *DeleteNumscriptRequest) Mutate() *DeleteNumscriptRequest { - return m.CloneVT() -} - -// DeleteNumscriptRequestListReader provides read-only iteration over []*DeleteNumscriptRequest. -type DeleteNumscriptRequestListReader interface { - Len() int - Get(i int) DeleteNumscriptRequestReader - Range(yield func(int, DeleteNumscriptRequestReader) bool) -} - -type deleteNumscriptRequestListReadonly []*DeleteNumscriptRequest - -func (l deleteNumscriptRequestListReadonly) Len() int { return len(l) } - -func (l deleteNumscriptRequestListReadonly) Get(i int) DeleteNumscriptRequestReader { - v := l[i] - if v == nil { - return nil - } - return v.AsReader() -} - -func (l deleteNumscriptRequestListReadonly) Range(yield func(int, DeleteNumscriptRequestReader) bool) { - for i, v := range l { - var r DeleteNumscriptRequestReader - if v != nil { - r = v.AsReader() - } - if !yield(i, r) { - return - } - } -} - -// NewDeleteNumscriptRequestListReader wraps s for read-only iteration. The returned -// view aliases the underlying slice; do not mutate s afterwards. -func NewDeleteNumscriptRequestListReader(s []*DeleteNumscriptRequest) DeleteNumscriptRequestListReader { - return deleteNumscriptRequestListReadonly(s) -} - // GetNumscriptRequestReader provides read-only access to GetNumscriptRequest. // Call Mutate() to obtain a mutable clone. type GetNumscriptRequestReader interface { @@ -3040,6 +2968,159 @@ func NewListNumscriptsRequestListReader(s []*ListNumscriptsRequest) ListNumscrip return listNumscriptsRequestListReadonly(s) } +// ListNumscriptVersionsRequestReader provides read-only access to ListNumscriptVersionsRequest. +// Call Mutate() to obtain a mutable clone. +type ListNumscriptVersionsRequestReader interface { + GetLedger() string + GetName() string + GetRead() commonpb.ReadOptionsReader + Mutate() *ListNumscriptVersionsRequest +} + +type listNumscriptVersionsRequestReadonly ListNumscriptVersionsRequest + +func (r *listNumscriptVersionsRequestReadonly) GetLedger() string { + return (*ListNumscriptVersionsRequest)(r).GetLedger() +} + +func (r *listNumscriptVersionsRequestReadonly) GetName() string { + return (*ListNumscriptVersionsRequest)(r).GetName() +} + +func (r *listNumscriptVersionsRequestReadonly) GetRead() commonpb.ReadOptionsReader { + v := (*ListNumscriptVersionsRequest)(r).GetRead() + if v == nil { + return nil + } + return v.AsReader() +} + +func (r *listNumscriptVersionsRequestReadonly) Mutate() *ListNumscriptVersionsRequest { + return (*ListNumscriptVersionsRequest)(r).CloneVT() +} + +// AsReader returns a read-only view of this ListNumscriptVersionsRequest. +func (m *ListNumscriptVersionsRequest) AsReader() ListNumscriptVersionsRequestReader { + if m == nil { + return nil + } + return (*listNumscriptVersionsRequestReadonly)(m) +} + +// Mutate returns a mutable deep clone of this ListNumscriptVersionsRequest. +func (m *ListNumscriptVersionsRequest) Mutate() *ListNumscriptVersionsRequest { + return m.CloneVT() +} + +// ListNumscriptVersionsRequestListReader provides read-only iteration over []*ListNumscriptVersionsRequest. +type ListNumscriptVersionsRequestListReader interface { + Len() int + Get(i int) ListNumscriptVersionsRequestReader + Range(yield func(int, ListNumscriptVersionsRequestReader) bool) +} + +type listNumscriptVersionsRequestListReadonly []*ListNumscriptVersionsRequest + +func (l listNumscriptVersionsRequestListReadonly) Len() int { return len(l) } + +func (l listNumscriptVersionsRequestListReadonly) Get(i int) ListNumscriptVersionsRequestReader { + v := l[i] + if v == nil { + return nil + } + return v.AsReader() +} + +func (l listNumscriptVersionsRequestListReadonly) Range(yield func(int, ListNumscriptVersionsRequestReader) bool) { + for i, v := range l { + var r ListNumscriptVersionsRequestReader + if v != nil { + r = v.AsReader() + } + if !yield(i, r) { + return + } + } +} + +// NewListNumscriptVersionsRequestListReader wraps s for read-only iteration. The returned +// view aliases the underlying slice; do not mutate s afterwards. +func NewListNumscriptVersionsRequestListReader(s []*ListNumscriptVersionsRequest) ListNumscriptVersionsRequestListReader { + return listNumscriptVersionsRequestListReadonly(s) +} + +// ListNumscriptVersionsResponseReader provides read-only access to ListNumscriptVersionsResponse. +// Call Mutate() to obtain a mutable clone. +type ListNumscriptVersionsResponseReader interface { + GetLatestVersion() string + GetVersions() commonpb.NumscriptVersionEntryListReader + Mutate() *ListNumscriptVersionsResponse +} + +type listNumscriptVersionsResponseReadonly ListNumscriptVersionsResponse + +func (r *listNumscriptVersionsResponseReadonly) GetLatestVersion() string { + return (*ListNumscriptVersionsResponse)(r).GetLatestVersion() +} + +func (r *listNumscriptVersionsResponseReadonly) GetVersions() commonpb.NumscriptVersionEntryListReader { + return commonpb.NewNumscriptVersionEntryListReader((*ListNumscriptVersionsResponse)(r).GetVersions()) +} + +func (r *listNumscriptVersionsResponseReadonly) Mutate() *ListNumscriptVersionsResponse { + return (*ListNumscriptVersionsResponse)(r).CloneVT() +} + +// AsReader returns a read-only view of this ListNumscriptVersionsResponse. +func (m *ListNumscriptVersionsResponse) AsReader() ListNumscriptVersionsResponseReader { + if m == nil { + return nil + } + return (*listNumscriptVersionsResponseReadonly)(m) +} + +// Mutate returns a mutable deep clone of this ListNumscriptVersionsResponse. +func (m *ListNumscriptVersionsResponse) Mutate() *ListNumscriptVersionsResponse { + return m.CloneVT() +} + +// ListNumscriptVersionsResponseListReader provides read-only iteration over []*ListNumscriptVersionsResponse. +type ListNumscriptVersionsResponseListReader interface { + Len() int + Get(i int) ListNumscriptVersionsResponseReader + Range(yield func(int, ListNumscriptVersionsResponseReader) bool) +} + +type listNumscriptVersionsResponseListReadonly []*ListNumscriptVersionsResponse + +func (l listNumscriptVersionsResponseListReadonly) Len() int { return len(l) } + +func (l listNumscriptVersionsResponseListReadonly) Get(i int) ListNumscriptVersionsResponseReader { + v := l[i] + if v == nil { + return nil + } + return v.AsReader() +} + +func (l listNumscriptVersionsResponseListReadonly) Range(yield func(int, ListNumscriptVersionsResponseReader) bool) { + for i, v := range l { + var r ListNumscriptVersionsResponseReader + if v != nil { + r = v.AsReader() + } + if !yield(i, r) { + return + } + } +} + +// NewListNumscriptVersionsResponseListReader wraps s for read-only iteration. The returned +// view aliases the underlying slice; do not mutate s afterwards. +func NewListNumscriptVersionsResponseListReader(s []*ListNumscriptVersionsResponse) ListNumscriptVersionsResponseListReader { + return listNumscriptVersionsResponseListReadonly(s) +} + // GetTemplateUsageRequestReader provides read-only access to GetTemplateUsageRequest. // Call Mutate() to obtain a mutable clone. type GetTemplateUsageRequestReader interface { diff --git a/internal/proto/servicepb/bucket_vtproto.pb.go b/internal/proto/servicepb/bucket_vtproto.pb.go index edaa4375ee..1203922888 100644 --- a/internal/proto/servicepb/bucket_vtproto.pb.go +++ b/internal/proto/servicepb/bucket_vtproto.pb.go @@ -539,15 +539,6 @@ func (m *Request_SaveNumscript) CloneVT() isRequest_Type { return r } -func (m *Request_DeleteNumscript) CloneVT() isRequest_Type { - if m == nil { - return (*Request_DeleteNumscript)(nil) - } - r := new(Request_DeleteNumscript) - r.DeleteNumscript = m.DeleteNumscript.CloneVT() - return r -} - func (m *Request_AddAccountType) CloneVT() isRequest_Type { if m == nil { return (*Request_AddAccountType)(nil) @@ -1068,13 +1059,15 @@ func (m *SaveNumscriptRequest) CloneMessageVT() proto.Message { return m.CloneVT() } -func (m *DeleteNumscriptRequest) CloneVT() *DeleteNumscriptRequest { +func (m *GetNumscriptRequest) CloneVT() *GetNumscriptRequest { if m == nil { - return (*DeleteNumscriptRequest)(nil) + return (*GetNumscriptRequest)(nil) } - r := new(DeleteNumscriptRequest) + r := new(GetNumscriptRequest) r.Name = m.Name + r.Version = m.Version r.Ledger = m.Ledger + r.Read = m.Read.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) @@ -1082,19 +1075,17 @@ func (m *DeleteNumscriptRequest) CloneVT() *DeleteNumscriptRequest { return r } -func (m *DeleteNumscriptRequest) CloneMessageVT() proto.Message { +func (m *GetNumscriptRequest) CloneMessageVT() proto.Message { return m.CloneVT() } -func (m *GetNumscriptRequest) CloneVT() *GetNumscriptRequest { +func (m *ListNumscriptsRequest) CloneVT() *ListNumscriptsRequest { if m == nil { - return (*GetNumscriptRequest)(nil) + return (*ListNumscriptsRequest)(nil) } - r := new(GetNumscriptRequest) - r.Name = m.Name - r.Version = m.Version + r := new(ListNumscriptsRequest) r.Ledger = m.Ledger - r.Read = m.Read.CloneVT() + r.Options = m.Options.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) @@ -1102,17 +1093,18 @@ func (m *GetNumscriptRequest) CloneVT() *GetNumscriptRequest { return r } -func (m *GetNumscriptRequest) CloneMessageVT() proto.Message { +func (m *ListNumscriptsRequest) CloneMessageVT() proto.Message { return m.CloneVT() } -func (m *ListNumscriptsRequest) CloneVT() *ListNumscriptsRequest { +func (m *ListNumscriptVersionsRequest) CloneVT() *ListNumscriptVersionsRequest { if m == nil { - return (*ListNumscriptsRequest)(nil) + return (*ListNumscriptVersionsRequest)(nil) } - r := new(ListNumscriptsRequest) + r := new(ListNumscriptVersionsRequest) r.Ledger = m.Ledger - r.Options = m.Options.CloneVT() + r.Name = m.Name + r.Read = m.Read.CloneVT() if len(m.unknownFields) > 0 { r.unknownFields = make([]byte, len(m.unknownFields)) copy(r.unknownFields, m.unknownFields) @@ -1120,7 +1112,31 @@ func (m *ListNumscriptsRequest) CloneVT() *ListNumscriptsRequest { return r } -func (m *ListNumscriptsRequest) CloneMessageVT() proto.Message { +func (m *ListNumscriptVersionsRequest) CloneMessageVT() proto.Message { + return m.CloneVT() +} + +func (m *ListNumscriptVersionsResponse) CloneVT() *ListNumscriptVersionsResponse { + if m == nil { + return (*ListNumscriptVersionsResponse)(nil) + } + r := new(ListNumscriptVersionsResponse) + r.LatestVersion = m.LatestVersion + if rhs := m.Versions; rhs != nil { + tmpContainer := make([]*commonpb.NumscriptVersionEntry, len(rhs)) + for k, v := range rhs { + tmpContainer[k] = v.CloneVT() + } + r.Versions = tmpContainer + } + if len(m.unknownFields) > 0 { + r.unknownFields = make([]byte, len(m.unknownFields)) + copy(r.unknownFields, m.unknownFields) + } + return r +} + +func (m *ListNumscriptVersionsResponse) CloneMessageVT() proto.Message { return m.CloneVT() } @@ -4224,31 +4240,6 @@ func (this *Request_SaveNumscript) EqualVT(thatIface isRequest_Type) bool { return true } -func (this *Request_DeleteNumscript) EqualVT(thatIface isRequest_Type) bool { - that, ok := thatIface.(*Request_DeleteNumscript) - if !ok { - return false - } - if this == that { - return true - } - if this == nil && that != nil || this != nil && that == nil { - return false - } - if p, q := this.DeleteNumscript, that.DeleteNumscript; p != q { - if p == nil { - p = &DeleteNumscriptRequest{} - } - if q == nil { - q = &DeleteNumscriptRequest{} - } - if !p.EqualVT(q) { - return false - } - } - return true -} - func (this *Request_AddAccountType) EqualVT(thatIface isRequest_Type) bool { that, ok := thatIface.(*Request_AddAccountType) if !ok { @@ -4986,7 +4977,7 @@ func (this *SaveNumscriptRequest) EqualMessageVT(thatMsg proto.Message) bool { } return this.EqualVT(that) } -func (this *DeleteNumscriptRequest) EqualVT(that *DeleteNumscriptRequest) bool { +func (this *GetNumscriptRequest) EqualVT(that *GetNumscriptRequest) bool { if this == that { return true } else if this == nil || that == nil { @@ -4995,64 +4986,103 @@ func (this *DeleteNumscriptRequest) EqualVT(that *DeleteNumscriptRequest) bool { if this.Name != that.Name { return false } + if this.Version != that.Version { + return false + } if this.Ledger != that.Ledger { return false } + if !this.Read.EqualVT(that.Read) { + return false + } return string(this.unknownFields) == string(that.unknownFields) } -func (this *DeleteNumscriptRequest) EqualMessageVT(thatMsg proto.Message) bool { - that, ok := thatMsg.(*DeleteNumscriptRequest) +func (this *GetNumscriptRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*GetNumscriptRequest) if !ok { return false } return this.EqualVT(that) } -func (this *GetNumscriptRequest) EqualVT(that *GetNumscriptRequest) bool { +func (this *ListNumscriptsRequest) EqualVT(that *ListNumscriptsRequest) bool { if this == that { return true } else if this == nil || that == nil { return false } - if this.Name != that.Name { + if this.Ledger != that.Ledger { return false } - if this.Version != that.Version { + if !this.Options.EqualVT(that.Options) { + return false + } + return string(this.unknownFields) == string(that.unknownFields) +} + +func (this *ListNumscriptsRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ListNumscriptsRequest) + if !ok { + return false + } + return this.EqualVT(that) +} +func (this *ListNumscriptVersionsRequest) EqualVT(that *ListNumscriptVersionsRequest) bool { + if this == that { + return true + } else if this == nil || that == nil { return false } if this.Ledger != that.Ledger { return false } + if this.Name != that.Name { + return false + } if !this.Read.EqualVT(that.Read) { return false } return string(this.unknownFields) == string(that.unknownFields) } -func (this *GetNumscriptRequest) EqualMessageVT(thatMsg proto.Message) bool { - that, ok := thatMsg.(*GetNumscriptRequest) +func (this *ListNumscriptVersionsRequest) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ListNumscriptVersionsRequest) if !ok { return false } return this.EqualVT(that) } -func (this *ListNumscriptsRequest) EqualVT(that *ListNumscriptsRequest) bool { +func (this *ListNumscriptVersionsResponse) EqualVT(that *ListNumscriptVersionsResponse) bool { if this == that { return true } else if this == nil || that == nil { return false } - if this.Ledger != that.Ledger { + if this.LatestVersion != that.LatestVersion { return false } - if !this.Options.EqualVT(that.Options) { + if len(this.Versions) != len(that.Versions) { return false } + for i, vx := range this.Versions { + vy := that.Versions[i] + if p, q := vx, vy; p != q { + if p == nil { + p = &commonpb.NumscriptVersionEntry{} + } + if q == nil { + q = &commonpb.NumscriptVersionEntry{} + } + if !p.EqualVT(q) { + return false + } + } + } return string(this.unknownFields) == string(that.unknownFields) } -func (this *ListNumscriptsRequest) EqualMessageVT(thatMsg proto.Message) bool { - that, ok := thatMsg.(*ListNumscriptsRequest) +func (this *ListNumscriptVersionsResponse) EqualMessageVT(thatMsg proto.Message) bool { + that, ok := thatMsg.(*ListNumscriptVersionsResponse) if !ok { return false } @@ -9437,27 +9467,6 @@ func (m *Request_SaveNumscript) MarshalToSizedBufferVT(dAtA []byte) (int, error) } return len(dAtA) - i, nil } -func (m *Request_DeleteNumscript) MarshalToVT(dAtA []byte) (int, error) { - size := m.SizeVT() - return m.MarshalToSizedBufferVT(dAtA[:size]) -} - -func (m *Request_DeleteNumscript) MarshalToSizedBufferVT(dAtA []byte) (int, error) { - i := len(dAtA) - if m.DeleteNumscript != nil { - size, err := m.DeleteNumscript.MarshalToSizedBufferVT(dAtA[:i]) - if err != nil { - return 0, err - } - i -= size - i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) - i-- - dAtA[i] = 0x1 - i-- - dAtA[i] = 0xe2 - } - return len(dAtA) - i, nil -} func (m *Request_AddAccountType) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) @@ -10727,7 +10736,7 @@ func (m *SaveNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) return len(dAtA) - i, nil } -func (m *DeleteNumscriptRequest) MarshalVT() (dAtA []byte, err error) { +func (m *GetNumscriptRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -10740,12 +10749,12 @@ func (m *DeleteNumscriptRequest) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *DeleteNumscriptRequest) MarshalToVT(dAtA []byte) (int, error) { +func (m *GetNumscriptRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *DeleteNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *GetNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -10757,11 +10766,28 @@ func (m *DeleteNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } + if m.Read != nil { + size, err := m.Read.MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x22 + } if len(m.Ledger) > 0 { i -= len(m.Ledger) copy(dAtA[i:], m.Ledger) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ledger))) i-- + dAtA[i] = 0x1a + } + if len(m.Version) > 0 { + i -= len(m.Version) + copy(dAtA[i:], m.Version) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) + i-- dAtA[i] = 0x12 } if len(m.Name) > 0 { @@ -10774,7 +10800,7 @@ func (m *DeleteNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error return len(dAtA) - i, nil } -func (m *GetNumscriptRequest) MarshalVT() (dAtA []byte, err error) { +func (m *ListNumscriptsRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -10787,12 +10813,12 @@ func (m *GetNumscriptRequest) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *GetNumscriptRequest) MarshalToVT(dAtA []byte) (int, error) { +func (m *ListNumscriptsRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *GetNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ListNumscriptsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -10804,41 +10830,27 @@ func (m *GetNumscriptRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Read != nil { - size, err := m.Read.MarshalToSizedBufferVT(dAtA[:i]) + if m.Options != nil { + size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- - dAtA[i] = 0x22 + dAtA[i] = 0x12 } if len(m.Ledger) > 0 { i -= len(m.Ledger) copy(dAtA[i:], m.Ledger) i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Ledger))) i-- - dAtA[i] = 0x1a - } - if len(m.Version) > 0 { - i -= len(m.Version) - copy(dAtA[i:], m.Version) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Version))) - i-- - dAtA[i] = 0x12 - } - if len(m.Name) > 0 { - i -= len(m.Name) - copy(dAtA[i:], m.Name) - i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) - i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } -func (m *ListNumscriptsRequest) MarshalVT() (dAtA []byte, err error) { +func (m *ListNumscriptVersionsRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil } @@ -10851,12 +10863,12 @@ func (m *ListNumscriptsRequest) MarshalVT() (dAtA []byte, err error) { return dAtA[:n], nil } -func (m *ListNumscriptsRequest) MarshalToVT(dAtA []byte) (int, error) { +func (m *ListNumscriptVersionsRequest) MarshalToVT(dAtA []byte) (int, error) { size := m.SizeVT() return m.MarshalToSizedBufferVT(dAtA[:size]) } -func (m *ListNumscriptsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { +func (m *ListNumscriptVersionsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) { if m == nil { return 0, nil } @@ -10868,14 +10880,21 @@ func (m *ListNumscriptsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) i -= len(m.unknownFields) copy(dAtA[i:], m.unknownFields) } - if m.Options != nil { - size, err := m.Options.MarshalToSizedBufferVT(dAtA[:i]) + if m.Read != nil { + size, err := m.Read.MarshalToSizedBufferVT(dAtA[:i]) if err != nil { return 0, err } i -= size i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) i-- + dAtA[i] = 0x1a + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name))) + i-- dAtA[i] = 0x12 } if len(m.Ledger) > 0 { @@ -10888,6 +10907,58 @@ func (m *ListNumscriptsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) return len(dAtA) - i, nil } +func (m *ListNumscriptVersionsResponse) MarshalVT() (dAtA []byte, err error) { + if m == nil { + return nil, nil + } + size := m.SizeVT() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBufferVT(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ListNumscriptVersionsResponse) MarshalToVT(dAtA []byte) (int, error) { + size := m.SizeVT() + return m.MarshalToSizedBufferVT(dAtA[:size]) +} + +func (m *ListNumscriptVersionsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) { + if m == nil { + return 0, nil + } + i := len(dAtA) + _ = i + var l int + _ = l + if m.unknownFields != nil { + i -= len(m.unknownFields) + copy(dAtA[i:], m.unknownFields) + } + if len(m.Versions) > 0 { + for iNdEx := len(m.Versions) - 1; iNdEx >= 0; iNdEx-- { + size, err := m.Versions[iNdEx].MarshalToSizedBufferVT(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = protohelpers.EncodeVarint(dAtA, i, uint64(size)) + i-- + dAtA[i] = 0x12 + } + } + if len(m.LatestVersion) > 0 { + i -= len(m.LatestVersion) + copy(dAtA[i:], m.LatestVersion) + i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.LatestVersion))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *GetTemplateUsageRequest) MarshalVT() (dAtA []byte, err error) { if m == nil { return nil, nil @@ -16863,18 +16934,6 @@ func (m *Request_SaveNumscript) SizeVT() (n int) { } return n } -func (m *Request_DeleteNumscript) SizeVT() (n int) { - if m == nil { - return 0 - } - var l int - _ = l - if m.DeleteNumscript != nil { - l = m.DeleteNumscript.SizeVT() - n += 2 + l + protohelpers.SizeOfVarint(uint64(l)) - } - return n -} func (m *Request_AddAccountType) SizeVT() (n int) { if m == nil { return 0 @@ -17370,7 +17429,7 @@ func (m *SaveNumscriptRequest) SizeVT() (n int) { return n } -func (m *DeleteNumscriptRequest) SizeVT() (n int) { +func (m *GetNumscriptRequest) SizeVT() (n int) { if m == nil { return 0 } @@ -17380,32 +17439,54 @@ func (m *DeleteNumscriptRequest) SizeVT() (n int) { if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } + l = len(m.Version) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } l = len(m.Ledger) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } + if m.Read != nil { + l = m.Read.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } n += len(m.unknownFields) return n } -func (m *GetNumscriptRequest) SizeVT() (n int) { +func (m *ListNumscriptsRequest) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Name) + l = len(m.Ledger) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } - l = len(m.Version) - if l > 0 { + if m.Options != nil { + l = m.Options.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } + n += len(m.unknownFields) + return n +} + +func (m *ListNumscriptVersionsRequest) SizeVT() (n int) { + if m == nil { + return 0 + } + var l int + _ = l l = len(m.Ledger) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } + l = len(m.Name) + if l > 0 { + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } if m.Read != nil { l = m.Read.SizeVT() n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) @@ -17414,19 +17495,21 @@ func (m *GetNumscriptRequest) SizeVT() (n int) { return n } -func (m *ListNumscriptsRequest) SizeVT() (n int) { +func (m *ListNumscriptVersionsResponse) SizeVT() (n int) { if m == nil { return 0 } var l int _ = l - l = len(m.Ledger) + l = len(m.LatestVersion) if l > 0 { n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) } - if m.Options != nil { - l = m.Options.SizeVT() - n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + if len(m.Versions) > 0 { + for _, e := range m.Versions { + l = e.SizeVT() + n += 1 + l + protohelpers.SizeOfVarint(uint64(l)) + } } n += len(m.unknownFields) return n @@ -22276,47 +22359,6 @@ func (m *Request) UnmarshalVT(dAtA []byte) error { m.Type = &Request_SaveNumscript{SaveNumscript: v} } iNdEx = postIndex - case 28: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field DeleteNumscript", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return protohelpers.ErrIntOverflow - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return protohelpers.ErrInvalidLength - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return protohelpers.ErrInvalidLength - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if oneof, ok := m.Type.(*Request_DeleteNumscript); ok { - if err := oneof.DeleteNumscript.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - } else { - v := &DeleteNumscriptRequest{} - if err := v.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { - return err - } - m.Type = &Request_DeleteNumscript{DeleteNumscript: v} - } - iNdEx = postIndex case 29: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AddAccountType", wireType) @@ -25076,7 +25118,7 @@ func (m *SaveNumscriptRequest) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *DeleteNumscriptRequest) UnmarshalVT(dAtA []byte) error { +func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25099,10 +25141,10 @@ func (m *DeleteNumscriptRequest) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: DeleteNumscriptRequest: wiretype end group for non-group") + return fmt.Errorf("proto: GetNumscriptRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: DeleteNumscriptRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: GetNumscriptRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -25138,6 +25180,38 @@ func (m *DeleteNumscriptRequest) UnmarshalVT(dAtA []byte) error { m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Version = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) } @@ -25169,6 +25243,42 @@ func (m *DeleteNumscriptRequest) UnmarshalVT(dAtA []byte) error { } m.Ledger = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Read == nil { + m.Read = &commonpb.ReadOptions{} + } + if err := m.Read.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := protohelpers.Skip(dAtA[iNdEx:]) @@ -25191,7 +25301,7 @@ func (m *DeleteNumscriptRequest) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { +func (m *ListNumscriptsRequest) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25214,15 +25324,15 @@ func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: GetNumscriptRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ListNumscriptsRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: GetNumscriptRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ListNumscriptsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -25250,11 +25360,98 @@ func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Name = string(dAtA[iNdEx:postIndex]) + m.Ledger = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return protohelpers.ErrInvalidLength + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return protohelpers.ErrInvalidLength + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Options == nil { + m.Options = &commonpb.ListOptions{} + } + if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := protohelpers.Skip(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return protohelpers.ErrInvalidLength + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...) + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *ListNumscriptVersionsRequest) UnmarshalVT(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return protohelpers.ErrIntOverflow + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ListNumscriptVersionsRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ListNumscriptVersionsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -25282,11 +25479,11 @@ func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Version = string(dAtA[iNdEx:postIndex]) + m.Ledger = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 3: + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -25314,9 +25511,9 @@ func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Ledger = string(dAtA[iNdEx:postIndex]) + m.Name = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 4: + case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Read", wireType) } @@ -25374,7 +25571,7 @@ func (m *GetNumscriptRequest) UnmarshalVT(dAtA []byte) error { } return nil } -func (m *ListNumscriptsRequest) UnmarshalVT(dAtA []byte) error { +func (m *ListNumscriptVersionsResponse) UnmarshalVT(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -25397,15 +25594,15 @@ func (m *ListNumscriptsRequest) UnmarshalVT(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: ListNumscriptsRequest: wiretype end group for non-group") + return fmt.Errorf("proto: ListNumscriptVersionsResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: ListNumscriptsRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: ListNumscriptVersionsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Ledger", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field LatestVersion", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -25433,11 +25630,11 @@ func (m *ListNumscriptsRequest) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Ledger = string(dAtA[iNdEx:postIndex]) + m.LatestVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Options", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Versions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -25464,10 +25661,8 @@ func (m *ListNumscriptsRequest) UnmarshalVT(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Options == nil { - m.Options = &commonpb.ListOptions{} - } - if err := m.Options.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { + m.Versions = append(m.Versions, &commonpb.NumscriptVersionEntry{}) + if err := m.Versions[len(m.Versions)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex diff --git a/internal/query/numscript.go b/internal/query/numscript.go index 57e55645d3..734632a173 100644 --- a/internal/query/numscript.go +++ b/internal/query/numscript.go @@ -2,6 +2,7 @@ package query import ( "fmt" + "sort" "github.com/formancehq/ledger/v3/internal/domain" "github.com/formancehq/ledger/v3/internal/infra/attributes" @@ -10,9 +11,9 @@ import ( "github.com/formancehq/ledger/v3/internal/storage/dal" ) -// ReadNumscriptLatestVersion reads the latest version string for a numscript by ledger and name -// from the attributes zone (0xF1). -// Returns "" if the numscript does not exist. +// ReadNumscriptLatestVersion reads the per-name latest pointer (the greatest +// stored semver) from the attributes zone. Returns "" if the numscript does +// not exist. func ReadNumscriptLatestVersion(attr *attributes.Attribute[*commonpb.NumscriptVersionValue], reader dal.PebbleGetter, ledgerName string, name string) (string, error) { val, err := attr.Get(reader, domain.NumscriptVersionKey{LedgerName: ledgerName, Name: name}.Bytes()) if err != nil { @@ -26,12 +27,10 @@ func ReadNumscriptLatestVersion(attr *attributes.Attribute[*commonpb.NumscriptVe return val.GetVersion(), nil } -// ReadNumscript reads a numscript by ledger, name and version spec from the attributes zone (0xF1). -// - "" → read latest pointer, then fetch that version -// - "latest" → read latest pointer, then fetch that version -// - "1.0.0" → direct Get on exact version -// - "1.0" → scan all versions for (ledger, name), find highest matching -// - "1" → scan all versions for (ledger, name), find highest matching +// ReadNumscript reads a numscript by ledger, name and version spec: +// - "" / "latest" → the greatest stored semver (via the latest pointer) +// - "1.0.0" → direct Get on the exact version +// - "1" / "1.2" → highest matching semver (read-only partial selector) // // Returns nil if the numscript or version does not exist. func ReadNumscript( @@ -41,12 +40,7 @@ func ReadNumscript( ledgerName string, name string, version string, ) (*commonpb.NumscriptInfo, error) { - if version == "latest" { - // Direct lookup for the "latest" slot content. - return readNumscriptExact(contentAttr, reader, ledgerName, name, "latest") - } - - if version == "" { + if version == "" || version == "latest" { latestVersion, err := ReadNumscriptLatestVersion(versionAttr, reader, ledgerName, name) if err != nil { return nil, err @@ -71,15 +65,15 @@ func ReadNumscript( return resolvePartialVersion(contentAttr, reader, ledgerName, name, major, minor, depth) } -// ReadAllNumscripts lists all numscripts for a ledger by scanning the latest version pointers -// from the attributes zone, then fetching each script's content. +// ReadAllNumscripts lists all numscripts for a ledger by scanning the latest +// pointers, then fetching each script's greatest version content. func ReadAllNumscripts( versionAttr *attributes.Attribute[*commonpb.NumscriptVersionValue], contentAttr *attributes.Attribute[*commonpb.NumscriptInfo], reader dal.PebbleReader, ledgerName string, ) ([]*commonpb.NumscriptInfo, error) { - // Scan all version pointers for this ledger. + // Scan all latest pointers for this ledger. // The canonical key prefix is [ledgerName padded 64B]. prefix := make([]byte, dal.LedgerNameFixedSize) copy(prefix, ledgerName) @@ -93,13 +87,11 @@ func ReadAllNumscripts( for _, entry := range entries { version := entry.Value.GetVersion() if version == "" { - continue // deleted + continue } // Reconstruct the name from the canonical key: [ledgerName padded 64B][name]. - // Skip the fixed-width ledger prefix. - nameBytes := entry.CanonicalKey[len(prefix):] - name := string(nameBytes) + name := string(entry.CanonicalKey[len(prefix):]) info, err := readNumscriptExact(contentAttr, reader, ledgerName, name, version) if err != nil { @@ -114,6 +106,53 @@ func ReadAllNumscripts( return scripts, nil } +// ReadAllNumscriptVersions returns the numscript's history: its current latest +// (greatest stored semver) and every stored version ordered highest-first. +func ReadAllNumscriptVersions( + versionAttr *attributes.Attribute[*commonpb.NumscriptVersionValue], + contentAttr *attributes.Attribute[*commonpb.NumscriptInfo], + reader dal.PebbleReader, + ledgerName string, name string, +) (string, []*commonpb.NumscriptVersionEntry, error) { + latest, err := ReadNumscriptLatestVersion(versionAttr, reader, ledgerName, name) + if err != nil { + return "", nil, err + } + + prefix := domain.NumscriptEntryKey{LedgerName: ledgerName, Name: name, Version: ""}.Bytes() + entries, err := contentAttr.ComputeAllForPrefix(reader, prefix) + if err != nil { + return "", nil, fmt.Errorf("scanning numscript versions for %q/%q: %w", ledgerName, name, err) + } + + versions := make([]*commonpb.NumscriptVersionEntry, 0, len(entries)) + for _, entry := range entries { + info := entry.Value + versions = append(versions, &commonpb.NumscriptVersionEntry{ + Version: info.GetVersion(), + CreatedAt: info.GetCreatedAt(), + }) + } + + sortNumscriptVersions(versions) + + return latest, versions, nil +} + +// sortNumscriptVersions orders stored versions highest-first by semver, with any +// unparseable version ordered last (lexically) for a stable, total order. +func sortNumscriptVersions(versions []*commonpb.NumscriptVersionEntry) { + sort.SliceStable(versions, func(i, j int) bool { + vi, ei := semver.Parse(versions[i].GetVersion()) + vj, ej := semver.Parse(versions[j].GetVersion()) + if ei != nil || ej != nil { + return versions[i].GetVersion() > versions[j].GetVersion() + } + + return vi.Compare(vj) > 0 + }) +} + // readNumscriptExact does a direct Get on the exact version key in the attributes zone. func readNumscriptExact(attr *attributes.Attribute[*commonpb.NumscriptInfo], reader dal.PebbleGetter, ledgerName string, name, version string) (*commonpb.NumscriptInfo, error) { return attr.Get(reader, domain.NumscriptEntryKey{LedgerName: ledgerName, Name: name, Version: version}.Bytes()) diff --git a/internal/query/numscript_internal_test.go b/internal/query/numscript_internal_test.go new file mode 100644 index 0000000000..486e060861 --- /dev/null +++ b/internal/query/numscript_internal_test.go @@ -0,0 +1,31 @@ +package query + +import ( + "testing" + + "github.com/stretchr/testify/require" + + "github.com/formancehq/ledger/v3/internal/proto/commonpb" +) + +// TestSortNumscriptVersions pins the deterministic order: stored semver versions +// highest-first. +func TestSortNumscriptVersions(t *testing.T) { + t.Parallel() + + entries := []*commonpb.NumscriptVersionEntry{ + {Version: "1.0.2"}, + {Version: "1.0.10"}, + {Version: "2.0.0"}, + {Version: "1.0.0"}, + } + + sortNumscriptVersions(entries) + + got := make([]string, len(entries)) + for i, e := range entries { + got[i] = e.GetVersion() + } + + require.Equal(t, []string{"2.0.0", "1.0.10", "1.0.2", "1.0.0"}, got) +} diff --git a/misc/proto/bucket.proto b/misc/proto/bucket.proto index 276a0b8e0f..301a8ff2f8 100644 --- a/misc/proto/bucket.proto +++ b/misc/proto/bucket.proto @@ -112,6 +112,9 @@ service BucketService { // usagebuilder subsystem. Eventually consistent — may lag the live FSM // by up to one usagebuilder tick interval. rpc GetTemplateUsage(GetTemplateUsageRequest) returns (common.TemplateUsage); + // ListNumscriptVersions returns the latest pointer and every stored version + // of a numscript, ordered greatest semver first. + rpc ListNumscriptVersions(ListNumscriptVersionsRequest) returns (ListNumscriptVersionsResponse); // InspectIndex scans a metadata index and returns distinct values, facets, or a summary rpc InspectIndex(InspectIndexRequest) returns (InspectIndexResponse); // Barrier proposes a no-op through Raft consensus. When it returns, all @@ -278,7 +281,6 @@ message Request { CreateIndexRequest create_index = 25; DropIndexRequest drop_index = 26; SaveNumscriptRequest save_numscript = 27; - DeleteNumscriptRequest delete_numscript = 28; AddAccountTypeLedgerRequest add_account_type = 29; RemoveAccountTypeLedgerRequest remove_account_type = 30; SetDefaultEnforcementModeLedgerRequest set_default_enforcement_mode = 31; @@ -432,8 +434,8 @@ message DropIndexRequest { // Numscript Library Messages // ============================================================================ -// SaveNumscriptRequest saves a numscript to the library. -// version must be a valid semver string (e.g. "1.0.0") or "latest" to overwrite the most recent version. +// SaveNumscriptRequest appends an immutable version to the library. version +// must be an explicit full semver (e.g. "1.0.0"). message SaveNumscriptRequest { string name = 1; string content = 2; @@ -441,16 +443,12 @@ message SaveNumscriptRequest { string ledger = 4; } -// DeleteNumscriptRequest removes a numscript from the library (versions preserved). -message DeleteNumscriptRequest { - string name = 1; - string ledger = 2; -} - -// GetNumscriptRequest retrieves a numscript by name and optional version. +// GetNumscriptRequest retrieves a numscript by name and version selector. +// version accepts an exact semver, a partial selector (e.g. "1", "1.2"), or +// "" / "latest" for the greatest stored semver. message GetNumscriptRequest { string name = 1; - string version = 2; // "" = latest + string version = 2; // "" = latest (greatest stored semver) string ledger = 3; common.ReadOptions read = 4; @@ -461,12 +459,26 @@ message GetNumscriptRequest { reserved "checkpoint_id"; } -// ListNumscriptsRequest lists all numscripts for a ledger (latest version of each). +// ListNumscriptsRequest lists all numscripts for a ledger (greatest version of each). message ListNumscriptsRequest { string ledger = 1; common.ListOptions options = 2; } +// ListNumscriptVersionsRequest lists every stored version of a single numscript. +message ListNumscriptVersionsRequest { + string ledger = 1; + string name = 2; + common.ReadOptions read = 3; +} + +// ListNumscriptVersionsResponse carries the numscript's history: the current +// latest (greatest stored semver) and every stored version. +message ListNumscriptVersionsResponse { + string latest_version = 1; + repeated common.NumscriptVersionEntry versions = 2; +} + // GetTemplateUsageRequest retrieves the invocation counter + last-used // timestamp for a Numscript template. The counter is materialised // asynchronously by the usagebuilder from the audit chain — expect up to @@ -869,6 +881,15 @@ enum CheckStoreErrorType { // EphemeralEvictedCount / TransientUsedCount are informational and excluded // (cf. Index BuildStatus). CHECK_STORE_ERROR_TYPE_BOUNDARY_MISMATCH = 18; + // Emitted when the numscript library projections (SubAttrNumscriptContent + // immutable version entries and SubAttrNumscriptVersion latest pointers) + // diverge from the state the checker re-derived by replaying SavedNumscript / + // DeleteLedger log payloads. Those projections are the source for reads, + // listing, version history and admission-side reference resolution; a stored + // content row that has no matching SavedNumscript, an altered content entry, + // or a latest pointer that is not the greatest saved semver is tampering. The + // audit chain is the source of truth. + CHECK_STORE_ERROR_TYPE_NUMSCRIPT_MISMATCH = 19; } message CheckStoreError { diff --git a/misc/proto/common.proto b/misc/proto/common.proto index a8c951022e..e3feeade0e 100644 --- a/misc/proto/common.proto +++ b/misc/proto/common.proto @@ -351,7 +351,6 @@ message LogPayload { UpdatedPreparedQueryLog updated_prepared_query = 19; DeletedPreparedQueryLog deleted_prepared_query = 20; SavedNumscriptLog saved_numscript = 21; - DeletedNumscriptLog deleted_numscript = 22; CreatedQueryCheckpointLog created_query_checkpoint = 23; DeletedQueryCheckpointLog deleted_query_checkpoint = 24; SetQueryCheckpointScheduleLog set_query_checkpoint_schedule = 25; @@ -514,7 +513,7 @@ enum EventType { // Numscript Library Messages // ============================================================================ -// NumscriptInfo represents a stored numscript with versioning. +// NumscriptInfo represents a stored, immutable numscript version. message NumscriptInfo { string name = 1; string content = 2; @@ -523,15 +522,15 @@ message NumscriptInfo { string ledger = 5; } -// SavedNumscriptLog records a numscript being saved to the library. +// SavedNumscriptLog records a numscript version being saved to the library. message SavedNumscriptLog { NumscriptInfo info = 1; } -// DeletedNumscriptLog records a numscript being deleted from the library. -message DeletedNumscriptLog { - string name = 1; - string ledger = 2; +// NumscriptVersionEntry describes one stored, immutable version of a numscript. +message NumscriptVersionEntry { + string version = 1; + Timestamp created_at = 2; } // TemplateUsage tracks per-template invocation usage. Persisted as a diff --git a/misc/proto/raft_cmd.proto b/misc/proto/raft_cmd.proto index 83bda39b78..7f50621e79 100644 --- a/misc/proto/raft_cmd.proto +++ b/misc/proto/raft_cmd.proto @@ -96,7 +96,6 @@ message LedgerScopedOrder { SaveLedgerMetadataOrder save_ledger_metadata = 7; DeleteLedgerMetadataOrder delete_ledger_metadata = 8; SaveNumscriptOrder save_numscript = 9; - DeleteNumscriptOrder delete_numscript = 10; CreatePreparedQueryOrder create_prepared_query = 11; UpdatePreparedQueryOrder update_prepared_query = 12; DeletePreparedQueryOrder delete_prepared_query = 13; @@ -190,16 +189,14 @@ message SetChapterScheduleOrder { message DeleteChapterScheduleOrder {} +// SaveNumscriptOrder appends an immutable version to the library. version must +// be an explicit full semver. message SaveNumscriptOrder { string name = 1; string content = 2; string version = 3; } -message DeleteNumscriptOrder { - string name = 1; -} - // CreateQueryCheckpointOrder triggers a physical Pebble checkpoint via Raft. // The FSM commits the current batch and the Applier creates snapshots of both // the main store and read index, enabling point-in-time queries. @@ -385,8 +382,11 @@ message CreateTransactionOrder { // an admission-derived technical hint, not part of the transaction's identity. } -// NumscriptReference identifies a numscript from the library to use for a transaction. -// The version is resolved by admission (fuzzy → exact) before entering the Raft log. +// NumscriptReference identifies a numscript from the library to use for a +// transaction. The version selector — "" / "latest" or an exact full semver +// (partial selectors are read-only, rejected here) — is carried verbatim into +// the audited order; admission only plans the reads, and the FSM resolves +// "latest" to the greatest stored semver at apply. message NumscriptReference { string name = 1; string version = 2; diff --git a/openapi.yml b/openapi.yml index 6c4af6a01d..aa30b32621 100644 --- a/openapi.yml +++ b/openapi.yml @@ -1522,7 +1522,7 @@ paths: /v3/{ledgerName}/numscripts: get: summary: List all numscripts - description: Returns a list of all saved numscripts for a ledger with their latest version info. + description: Returns every numscript for a ledger at its greatest stored version. operationId: listNumscripts tags: - Numscript Library @@ -1598,11 +1598,10 @@ paths: put: summary: Save a numscript description: | - Saves a numscript to a ledger's library. The `version` field in the request body controls - versioning behavior: - - A semver string (e.g. "2.0.0") creates a new version. Fails if the version already exists. - - The special value "latest" overwrites the content of the current latest version. - - If omitted or empty, defaults to "latest". + Appends an immutable version to a ledger's numscript library. The `version` + field must be an explicit full semver (e.g. "1.0.0"); it creates a new + version and fails if that version already exists. The per-name latest is + always the greatest stored semver. operationId: saveNumscript tags: - Numscript Library @@ -1633,21 +1632,18 @@ paths: parameters: ledgerName: '$request.path.ledgerName' name: '$response.body#/data/name' - DeleteSavedNumscript: - operationId: deleteNumscript - parameters: - ledgerName: '$request.path.ledgerName' - name: '$response.body#/data/name' '204': description: Numscript saved (no content returned) '400': - description: Bad request (invalid version format, parse error, etc.) + description: Bad request (version not an explicit full semver, parse error, etc.) content: application/json: schema: $ref: '#/components/schemas/ErrorResponse' '409': - description: Version already exists + description: | + The version already exists (`NUMSCRIPT_VERSION_ALREADY_EXISTS`). + Stored versions are immutable and cannot be overwritten. content: application/json: schema: @@ -1662,10 +1658,14 @@ paths: $ref: '#/components/schemas/ErrorResponse' '405': $ref: '#/components/responses/MethodNotAllowed' - delete: - summary: Delete a numscript - description: Deletes a numscript from a ledger's library. Removes the latest version entry. - operationId: deleteNumscript + + /v3/{ledgerName}/numscripts/{name}/versions: + get: + summary: List numscript versions + description: | + Returns the numscript's history: its current latest (greatest stored + semver) and every stored version, highest-first. + operationId: listNumscriptVersions tags: - Numscript Library parameters: @@ -1677,24 +1677,18 @@ paths: type: string description: Name of the numscript responses: - '204': - description: Numscript deleted successfully - '400': - $ref: '#/components/responses/BadRequest' - '404': - description: Numscript not found + '200': + description: Numscript versions retrieved successfully content: application/json: schema: - $ref: '#/components/schemas/ErrorResponse' + $ref: '#/components/schemas/ListNumscriptVersionsResponse' + '400': + $ref: '#/components/responses/BadRequest' '503': $ref: '#/components/responses/ServiceUnavailable' '500': - description: Internal server error - content: - application/json: - schema: - $ref: '#/components/schemas/ErrorResponse' + $ref: '#/components/responses/InternalServerError' '405': $ref: '#/components/responses/MethodNotAllowed' @@ -4670,6 +4664,7 @@ components: type: object required: - content + - version properties: content: type: string @@ -4677,10 +4672,9 @@ components: version: type: string description: | - Semver version string (e.g. "1.0.0") or the special value "latest". - - A semver string creates a new version. Fails if the version already exists. - - "latest" overwrites the content of the current latest version. - - If omitted or empty, defaults to "latest". + Explicit full semver (e.g. "1.0.0"). Appends a new immutable version; + fails if that version already exists. "latest" and partial selectors + are not accepted for save. example: "1.0.0" NumscriptInfo: @@ -4706,6 +4700,39 @@ components: type: string description: Ledger name this numscript belongs to + NumscriptVersionEntry: + type: object + required: + - version + properties: + version: + type: string + description: Stored semver version string (e.g. "1.0.0") + example: "1.0.0" + createdAt: + type: string + format: date-time + description: When this version was stored (ISO 8601 format) + + ListNumscriptVersionsResponse: + type: object + required: + - data + properties: + data: + type: object + properties: + latestVersion: + type: string + description: The current latest — the greatest stored semver + example: "2.0.0" + versions: + type: array + items: + $ref: '#/components/schemas/NumscriptVersionEntry' + description: Every stored version, highest-first + nullable: true + PromoteLedgerResponse: type: object required: diff --git a/pkg/actions/actions.go b/pkg/actions/actions.go index 1b3ad8c35a..67248d0a5c 100644 --- a/pkg/actions/actions.go +++ b/pkg/actions/actions.go @@ -520,19 +520,6 @@ func SaveTypedTransactionMetadataAction(ledgerName string, txID uint64, metadata } } -// SaveNumscriptAction creates an action for saving a numscript to the library. -func SaveNumscriptAction(ledger, name, content string) *servicepb.Request { - return &servicepb.Request{ - Type: &servicepb.Request_SaveNumscript{ - SaveNumscript: &servicepb.SaveNumscriptRequest{ - Ledger: ledger, - Name: name, - Content: content, - }, - }, - } -} - // SaveNumscriptWithVersionAction creates an action for saving a numscript with a specific version. func SaveNumscriptWithVersionAction(ledger, name, content, version string) *servicepb.Request { return &servicepb.Request{ @@ -547,18 +534,6 @@ func SaveNumscriptWithVersionAction(ledger, name, content, version string) *serv } } -// DeleteNumscriptAction creates an action for deleting a numscript from the library. -func DeleteNumscriptAction(ledger, name string) *servicepb.Request { - return &servicepb.Request{ - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Ledger: ledger, - Name: name, - }, - }, - } -} - // CreateScriptRefTransactionAction creates a transaction using a script reference from the library. func CreateScriptRefTransactionAction(ledgerName, scriptName, version string, vars map[string]string, metadata map[string]string) *servicepb.Request { return &servicepb.Request{ diff --git a/pkg/actions/read.go b/pkg/actions/read.go index c2eae90c7d..af73e54a98 100644 --- a/pkg/actions/read.go +++ b/pkg/actions/read.go @@ -85,6 +85,20 @@ func ListNumscripts(ctx context.Context, client servicepb.BucketServiceClient, l } } +// ListNumscriptVersions returns the numscript's current latest (greatest stored +// semver) and every stored version. +func ListNumscriptVersions(ctx context.Context, client servicepb.BucketServiceClient, ledger, name string) (string, []*commonpb.NumscriptVersionEntry, error) { + resp, err := client.ListNumscriptVersions(ctx, &servicepb.ListNumscriptVersionsRequest{ + Ledger: ledger, + Name: name, + }) + if err != nil { + return "", nil, err + } + + return resp.GetLatestVersion(), resp.GetVersions(), nil +} + // nextCursorFromTrailer returns the opaque cursor for the following page, or // "" when the server signaled end-of-stream (no trailer). Mirrors the // cmdutil.NextCursorFromTrailer helper without creating a CLI-package diff --git a/pkg/scenario/marketplace.go b/pkg/scenario/marketplace.go index 4d73d4ad65..f3c8f4525a 100644 --- a/pkg/scenario/marketplace.go +++ b/pkg/scenario/marketplace.go @@ -360,7 +360,7 @@ send $amount ( return err } - // --- DeleteNumscript --- + // --- SaveNumscript --- if _, err := r.Step("SaveTempNumscript", actions.SaveNumscriptWithVersionAction(MarketplaceLedger, "temp_script", `vars { monetary $amount @@ -372,11 +372,6 @@ send $amount ( ); err != nil { return err } - if _, err := r.Step("DeleteNumscript", - actions.DeleteNumscriptAction(MarketplaceLedger, "temp_script"), - ); err != nil { - return err - } return nil } diff --git a/tests/antithesis/workload/bin/cmds/main/parallel_driver_numscript_lifecycle/main.go b/tests/antithesis/workload/bin/cmds/main/parallel_driver_numscript_lifecycle/main.go index 559c3c952d..c501b4fc5a 100644 --- a/tests/antithesis/workload/bin/cmds/main/parallel_driver_numscript_lifecycle/main.go +++ b/tests/antithesis/workload/bin/cmds/main/parallel_driver_numscript_lifecycle/main.go @@ -102,17 +102,20 @@ func main() { "GetNumscript should return latest version", details.With(internal.Details{"expected": version2, "actual": nsInfo.GetVersion()})) - // 5. Delete the numscript. - _, err = client.Apply(ctx, servicepb.UnsignedApplyRequest("", &servicepb.Request{ - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Name: scriptName, - Ledger: ledger, - }, - }, - })) + // 5. ListNumscriptVersions should report the latest pointer at the + // greatest saved semver (the library is immutable append-only). + versions, err := client.ListNumscriptVersions(ctx, &servicepb.ListNumscriptVersionsRequest{ + Name: scriptName, + Ledger: ledger, + }) + if err != nil { + internal.LogCleanupError("list numscript versions", err) + return + } - assert.Sometimes(internal.IsTolerated(err), "should be able to delete numscript", details.With(internal.Details{"error": err})) + assert.AlwaysOrUnreachable(versions.GetLatestVersion() == version2, + "latest pointer should be the greatest saved semver", + details.With(internal.Details{"expected": version2, "actual": versions.GetLatestVersion()})) }) } diff --git a/tests/e2e/business/numscript_library_test.go b/tests/e2e/business/numscript_library_test.go index 4aee4afa12..ba22c04834 100644 --- a/tests/e2e/business/numscript_library_test.go +++ b/tests/e2e/business/numscript_library_test.go @@ -4,7 +4,6 @@ package business import ( "github.com/formancehq/ledger/v3/pkg/actions" - "time" "github.com/formancehq/ledger/v3/internal/domain" "github.com/formancehq/ledger/v3/internal/proto/commonpb" @@ -17,591 +16,138 @@ import ( var _ = Describe("Numscript Library", Ordered, func() { - Context("CRUD operations", Ordered, func() { - const ledgerName = "numscript-crud-ledger" - - const ( - paymentScript = ` -send [USD/2 100] ( + const script100 = `send [USD/2 100] ( source = @world destination = @users:alice -) -` - paymentScriptV2 = ` -send [USD/2 200] ( +)` + const script200 = `send [USD/2 200] ( source = @world destination = @users:alice -) -` - refundScript = ` -send [USD/2 50] ( - source = @world - destination = @users:bob -) -` - ) +)` + + Context("Immutable append-only library", Ordered, func() { + const ledgerName = "numscript-immutable-ledger" BeforeAll(func() { _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(ledgerName, nil))) Expect(err).To(Succeed()) }) - It("Should save a numscript and retrieve it", func() { - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "payment", paymentScript, "1.0.0"))) + It("Should save an explicit-semver version and retrieve it", func() { + resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script100, "1.0.0"))) Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - // Verify log payload - savedLog := resp.Logs[0].Payload.GetSavedNumscript() - Expect(savedLog).NotTo(BeNil()) - Expect(savedLog.Info.Name).To(Equal("payment")) - Expect(savedLog.Info.Content).To(Equal(paymentScript)) - Expect(savedLog.Info.Version).To(Equal("1.0.0")) - - // Get the numscript (version="" means latest) - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - }) - Expect(err).To(Succeed()) - Expect(info.Name).To(Equal("payment")) - Expect(info.Content).To(Equal(paymentScript)) - Expect(info.Version).To(Equal("1.0.0")) - }) - - It("Should save to the 'latest' version slot", func() { - // Save with version="" (defaults to "latest") — creates its own version slot - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptAction(ledgerName, "payment", paymentScriptV2))) - Expect(err).To(Succeed()) - Expect(resp.Logs[0].Payload.GetSavedNumscript().Info.Version).To(Equal("latest")) - - // version="" returns latest pointer, which is now "latest" - latest, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - }) - Expect(err).To(Succeed()) - Expect(latest.Version).To(Equal("latest")) - Expect(latest.Content).To(Equal(paymentScriptV2)) + saved := resp.Logs[0].Payload.GetSavedNumscript() + Expect(saved).NotTo(BeNil()) + Expect(saved.Info.Version).To(Equal("1.0.0")) - // v1.0.0 content is unchanged - v1, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - Version: "1.0.0", - }) + info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{Ledger: ledgerName, Name: "pay"}) Expect(err).To(Succeed()) - Expect(v1.Content).To(Equal(paymentScript)) + Expect(info.GetVersion()).To(Equal("1.0.0")) + Expect(info.GetContent()).To(Equal(script100)) }) - It("Should support versioning with semver", func() { - // Save v2.0.0 of "payment" - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "payment", paymentScript, "2.0.0"))) - Expect(err).To(Succeed()) - Expect(resp.Logs[0].Payload.GetSavedNumscript().Info.Version).To(Equal("2.0.0")) - - // version="" returns latest pointer (2.0.0) - latest, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - }) - Expect(err).To(Succeed()) - Expect(latest.Version).To(Equal("2.0.0")) - Expect(latest.Content).To(Equal(paymentScript)) - - // version="1.0.0" returns v1 (content unchanged) - v1, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - Version: "1.0.0", - }) - Expect(err).To(Succeed()) - Expect(v1.Version).To(Equal("1.0.0")) - Expect(v1.Content).To(Equal(paymentScript)) - - // version="2.0.0" returns v2 - v2, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - Version: "2.0.0", - }) + It("Should track the greatest semver as latest, even when saved out of order", func() { + _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script200, "2.0.0"))) Expect(err).To(Succeed()) - Expect(v2.Version).To(Equal("2.0.0")) - Expect(v2.Content).To(Equal(paymentScript)) - - // version="latest" still has the content from earlier save - latestSlot, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "payment", - Version: "latest", - }) + // Save a lower version after the greater one. + _, err = sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script100, "1.5.0"))) Expect(err).To(Succeed()) - Expect(latestSlot.Version).To(Equal("latest")) - Expect(latestSlot.Content).To(Equal(paymentScriptV2)) - }) - It("Should list numscripts", func() { - // Save a second numscript - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "refund", refundScript, "1.0.0"))) + latest, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{Ledger: ledgerName, Name: "pay"}) Expect(err).To(Succeed()) + Expect(latest.GetVersion()).To(Equal("2.0.0")) - scripts, err := actions.ListNumscripts(sharedCtx, sharedClient, ledgerName) + // Older versions remain retrievable and immutable. + v1, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{Ledger: ledgerName, Name: "pay", Version: "1.0.0"}) Expect(err).To(Succeed()) - Expect(scripts).To(HaveLen(2)) - - // Build a map by name for easier assertions - byName := make(map[string]*commonpb.NumscriptInfo) - for _, s := range scripts { - byName[s.Name] = s - } - Expect(byName).To(HaveKey("payment")) - Expect(byName).To(HaveKey("refund")) - // "payment" should return the latest version (2.0.0) - Expect(byName["payment"].Version).To(Equal("2.0.0")) + Expect(v1.GetContent()).To(Equal(script100)) }) - It("Should delete a numscript", func() { - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.DeleteNumscriptAction(ledgerName, "refund"))) - Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - Expect(resp.Logs[0].Payload.GetDeletedNumscript()).NotTo(BeNil()) - Expect(resp.Logs[0].Payload.GetDeletedNumscript().Name).To(Equal("refund")) - - // List should only have "payment" - scripts, err := actions.ListNumscripts(sharedCtx, sharedClient, ledgerName) - Expect(err).To(Succeed()) - Expect(scripts).To(HaveLen(1)) - Expect(scripts[0].Name).To(Equal("payment")) - - // Get "refund" should fail with NOT_FOUND - _, err = sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{Ledger: ledgerName, Name: "refund"}) + It("Should reject re-saving an existing version (immutable)", func() { + _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script200, "1.0.0"))) Expect(err).To(HaveOccurred()) st, ok := status.FromError(err) Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.NotFound)) - }) - - It("Should save v1 then save latest in the same batch", func() { - const batchScript = ` -send [EUR/2 1] ( - source = @world - destination = @users:charlie -) -` - const batchScriptLatest = ` -send [EUR/2 2] ( - source = @world - destination = @users:charlie -) -` - // Single batch: create v1.0.0 then save to "latest" slot - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "batch-script", batchScript, "1.0.0"), - actions.SaveNumscriptAction(ledgerName, "batch-script", batchScriptLatest))) - Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(2)) - - // First log: created v1.0.0 - saved1 := resp.Logs[0].Payload.GetSavedNumscript() - Expect(saved1).NotTo(BeNil()) - Expect(saved1.Info.Version).To(Equal("1.0.0")) - Expect(saved1.Info.Content).To(Equal(batchScript)) + Expect(st.Code()).To(Equal(codes.AlreadyExists)) - // Second log: created "latest" slot - saved2 := resp.Logs[1].Payload.GetSavedNumscript() - Expect(saved2).NotTo(BeNil()) - Expect(saved2.Info.Version).To(Equal("latest")) - Expect(saved2.Info.Content).To(Equal(batchScriptLatest)) - - // Verify final state: default Get returns latest pointer - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "batch-script", - }) - Expect(err).To(Succeed()) - Expect(info.Version).To(Equal("latest")) - Expect(info.Content).To(Equal(batchScriptLatest)) - - // v1.0.0 is untouched - v1, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "batch-script", - Version: "1.0.0", - }) - Expect(err).To(Succeed()) - Expect(v1.Content).To(Equal(batchScript)) - }) - }) - - Context("Partial version resolution", Ordered, func() { - const ledgerName = "numscript-partial-ledger" - const simpleScript = `send [USD/2 1] (source = @world destination = @x)` - - BeforeAll(func() { - // Create ledger and save multiple versions of "partial-test" to test range resolution - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(ledgerName, nil), - actions.SaveNumscriptWithVersionAction(ledgerName, "partial-test", simpleScript, "1.0.0"), - actions.SaveNumscriptWithVersionAction(ledgerName, "partial-test", simpleScript, "1.0.3"), - actions.SaveNumscriptWithVersionAction(ledgerName, "partial-test", simpleScript, "1.2.0"), - actions.SaveNumscriptWithVersionAction(ledgerName, "partial-test", simpleScript, "2.0.0"))) - Expect(err).To(Succeed()) - }) - - It("Should resolve '1.0' to highest 1.0.x", func() { - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "partial-test", - Version: "1.0", - }) - Expect(err).To(Succeed()) - Expect(info.Version).To(Equal("1.0.3")) - }) - - It("Should resolve '1' to highest 1.x.y", func() { - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "partial-test", - Version: "1", - }) - Expect(err).To(Succeed()) - Expect(info.Version).To(Equal("1.2.0")) - }) - - It("Should still resolve exact semver", func() { - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "partial-test", - Version: "1.0.0", - }) - Expect(err).To(Succeed()) - Expect(info.Version).To(Equal("1.0.0")) - }) - - It("Should return NOT_FOUND for non-matching partial", func() { - _, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "partial-test", - Version: "3", - }) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.NotFound)) + info := actions.ExtractGRPCErrorInfo(err) + Expect(info).NotTo(BeNil()) + Expect(info.Reason).To(Equal(domain.ErrReasonNumscriptVersionAlreadyExists)) }) - It("Should resolve partial version in ScriptReference", func() { - const txLedgerName = "partial-version-ledger" - - const transferScript = ` -vars { - account $destination - monetary $amount -} - -send $amount ( - source = @world - destination = $destination -) -` - // Create ledger and save two versions - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(txLedgerName, nil), - actions.SaveNumscriptWithVersionAction(txLedgerName, "transfer", transferScript, "1.0.0"), - actions.SaveNumscriptWithVersionAction(txLedgerName, "transfer", transferScript, "1.0.5"))) - Expect(err).To(Succeed()) - - // Use partial version "1.0" in script reference — should resolve to 1.0.5 - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(txLedgerName, "transfer", "1.0", map[string]string{ - "destination": "users:charlie", - "amount": "USD/2 42", - }, nil))) - Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - createdTx := resp.Logs[0].Payload.GetApply().Log.Data.GetCreatedTransaction() - Expect(createdTx).NotTo(BeNil()) - Expect(createdTx.Transaction.Postings).To(HaveLen(1)) - Expect(createdTx.Transaction.Postings[0].Amount.ToBigInt().String()).To(Equal("42")) + It("Should reject saving without an explicit full semver", func() { + for _, v := range []string{"", "latest", "1", "1.2"} { + _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script100, v))) + Expect(err).To(HaveOccurred(), "version %q must be rejected", v) + st, ok := status.FromError(err) + Expect(ok).To(BeTrue()) + Expect(st.Code()).To(Equal(codes.InvalidArgument)) + } }) - It("Should resolve major-only partial version in ScriptReference", func() { - const txLedgerName = "partial-major-ledger" - - const transferScript = ` -vars { - account $destination - monetary $amount -} - -send $amount ( - source = @world - destination = $destination -) -` - // Create ledger and save versions across minor ranges - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(txLedgerName, nil), - actions.SaveNumscriptWithVersionAction(txLedgerName, "major-transfer", transferScript, "1.0.0"), - actions.SaveNumscriptWithVersionAction(txLedgerName, "major-transfer", transferScript, "1.3.0"), - actions.SaveNumscriptWithVersionAction(txLedgerName, "major-transfer", transferScript, "2.0.0"))) - Expect(err).To(Succeed()) - - // Use version "1" — should resolve to 1.3.0 (highest 1.x.y) - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(txLedgerName, "major-transfer", "1", map[string]string{ - "destination": "users:delta", - "amount": "USD/2 77", - }, nil))) + It("Should list numscripts at their greatest version", func() { + scripts, err := actions.ListNumscripts(sharedCtx, sharedClient, ledgerName) Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - createdTx := resp.Logs[0].Payload.GetApply().Log.Data.GetCreatedTransaction() - Expect(createdTx).NotTo(BeNil()) - Expect(createdTx.Transaction.Postings).To(HaveLen(1)) - Expect(createdTx.Transaction.Postings[0].Amount.ToBigInt().String()).To(Equal("77")) + byName := map[string]*commonpb.NumscriptInfo{} + for _, s := range scripts { + byName[s.GetName()] = s + } + Expect(byName).To(HaveKey("pay")) + Expect(byName["pay"].GetVersion()).To(Equal("2.0.0")) }) - It("Should resolve latest version in ScriptReference when version is empty", func() { - const txLedgerName = "latest-ref-ledger" - - const transferScript = ` -vars { - account $destination - monetary $amount -} - -send $amount ( - source = @world - destination = $destination -) -` - // Create ledger and save multiple semver versions - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(txLedgerName, nil), - actions.SaveNumscriptWithVersionAction(txLedgerName, "latest-transfer", transferScript, "1.0.0"), - actions.SaveNumscriptWithVersionAction(txLedgerName, "latest-transfer", transferScript, "2.0.0"))) - Expect(err).To(Succeed()) - - // Use version "" — should resolve via latest pointer to 2.0.0 - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(txLedgerName, "latest-transfer", "", map[string]string{ - "destination": "users:echo", - "amount": "USD/2 99", - }, nil))) + It("Should list the version history with the current latest", func() { + latest, versions, err := actions.ListNumscriptVersions(sharedCtx, sharedClient, ledgerName, "pay") Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - createdTx := resp.Logs[0].Payload.GetApply().Log.Data.GetCreatedTransaction() - Expect(createdTx).NotTo(BeNil()) - Expect(createdTx.Transaction.Postings).To(HaveLen(1)) - Expect(createdTx.Transaction.Postings[0].Amount.ToBigInt().String()).To(Equal("99")) + Expect(latest).To(Equal("2.0.0")) + got := make([]string, len(versions)) + for i, v := range versions { + got[i] = v.GetVersion() + } + Expect(got).To(Equal([]string{"2.0.0", "1.5.0", "1.0.0"})) }) }) - Context("Script reference transactions", Ordered, func() { - const ledgerName = "numscript-lib-ledger" - - const sendPaymentScript = ` -vars { - account $source - account $destination - monetary $amount -} - -send $amount ( - source = $source - destination = $destination -) -` - const sendPaymentScriptV2 = ` -vars { - account $destination - monetary $amount -} - -send $amount ( - source = @world - destination = $destination -) -` + Context("Script references", Ordered, func() { + const ledgerName = "numscript-ref-ledger" BeforeAll(func() { - // Create ledger and save numscript - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(ledgerName, nil), - actions.SaveNumscriptWithVersionAction(ledgerName, "send_payment", sendPaymentScript, "1.0.0"))) + _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(ledgerName, nil))) Expect(err).To(Succeed()) - }) - - It("Should create a transaction using a script reference", func() { - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(ledgerName, "send_payment", "", map[string]string{ - "source": "world", - "destination": "users:alice", - "amount": "USD/2 1000", - }, nil))) + _, err = sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script100, "1.0.0"))) Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - createdTx := resp.Logs[0].Payload.GetApply().Log.Data.GetCreatedTransaction() - Expect(createdTx).NotTo(BeNil()) - Expect(createdTx.Transaction.Postings).To(HaveLen(1)) - Expect(createdTx.Transaction.Postings[0].Source).To(Equal("world")) - Expect(createdTx.Transaction.Postings[0].Destination).To(Equal("users:alice")) - Expect(createdTx.Transaction.Postings[0].Asset).To(Equal("USD/2")) - Expect(createdTx.Transaction.Postings[0].Amount.ToBigInt().String()).To(Equal("1000")) - - // Verify balance - Eventually(func(g Gomega) { - account, err := sharedClient.GetAccount(sharedCtx, &servicepb.GetAccountRequest{ - Ledger: ledgerName, - Address: "users:alice", - }) - g.Expect(err).To(Succeed()) - g.Expect(account.FindVolume("USD/2", "")).NotTo(BeNil(), "expected USD/2 entry on account") - g.Expect(account.FindVolume("USD/2", "").Balance).To(Equal("1000")) - }).Within(10 * time.Second).WithPolling(100 * time.Millisecond).Should(Succeed()) }) - It("Should use a specific version of the script reference", func() { - // Save v2 of "send_payment" (uses @world as source, no $source var) - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "send_payment", sendPaymentScriptV2, "2.0.0"))) - Expect(err).To(Succeed()) - - // Use version="1.0.0" explicitly (the old script that requires $source) - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(ledgerName, "send_payment", "1.0.0", map[string]string{ - "source": "world", - "destination": "users:bob", - "amount": "EUR/2 500", - }, nil))) + It("Should run a transaction using a latest reference", func() { + resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(ledgerName, "pay", "", nil, nil))) Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - createdTx := resp.Logs[0].Payload.GetApply().Log.Data.GetCreatedTransaction() - Expect(createdTx).NotTo(BeNil()) - Expect(createdTx.Transaction.Postings).To(HaveLen(1)) - Expect(createdTx.Transaction.Postings[0].Source).To(Equal("world")) - Expect(createdTx.Transaction.Postings[0].Destination).To(Equal("users:bob")) - Expect(createdTx.Transaction.Postings[0].Amount.ToBigInt().String()).To(Equal("500")) + Expect(resp.Logs[0].Payload.GetApply()).NotTo(BeNil()) }) - }) - - Context("Error cases", Ordered, func() { - const ledgerName = "numscript-err-ledger" - BeforeAll(func() { - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(ledgerName, nil))) + It("Should run a transaction using an exact-version reference", func() { + resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(ledgerName, "pay", "1.0.0", nil, nil))) Expect(err).To(Succeed()) + Expect(resp.Logs[0].Payload.GetApply()).NotTo(BeNil()) }) - It("Should reject saving a numscript with empty name", func() { - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "", "send [USD/2 1] (source = @world destination = @x)", "1.0.0"))) + It("Should reject an executable partial-version reference", func() { + _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(ledgerName, "pay", "1", nil, nil))) Expect(err).To(HaveOccurred()) st, ok := status.FromError(err) Expect(ok).To(BeTrue()) Expect(st.Code()).To(Equal(codes.InvalidArgument)) }) - It("Should reject saving a numscript with invalid syntax", func() { - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "bad-script", "this is not valid numscript", "1.0.0"))) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.InvalidArgument)) - - info := actions.ExtractGRPCErrorInfo(err) - Expect(info).NotTo(BeNil()) - Expect(info.Reason).To(Equal(domain.ErrReasonNumscriptParseError)) - }) - - It("Should reject deleting a non-existent numscript", func() { - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.DeleteNumscriptAction(ledgerName, "does-not-exist"))) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.NotFound)) - - info := actions.ExtractGRPCErrorInfo(err) - Expect(info).NotTo(BeNil()) - Expect(info.Reason).To(Equal(domain.ErrReasonNumscriptNotFound)) - }) - - It("Should reject getting a non-existent numscript", func() { - _, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "does-not-exist", - }) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.NotFound)) - }) - - It("Should reject script reference with non-existent name", func() { - const txLedgerName = "numscript-lib-err-ledger" - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateLedgerAction(txLedgerName, nil))) + It("Should resolve a same-bulk save for a later latest reference", func() { + // A save of a new greatest version followed by a latest reference in the + // same bulk must run the just-saved version (read-your-writes). + resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", + actions.SaveNumscriptWithVersionAction(ledgerName, "pay", script200, "3.0.0"), + actions.CreateScriptRefTransactionAction(ledgerName, "pay", "", nil, nil), + )) Expect(err).To(Succeed()) - - _, err = sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.CreateScriptRefTransactionAction(txLedgerName, "nonexistent-script", "", map[string]string{ - "amount": "USD/2 100", - }, nil))) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.NotFound)) - - info := actions.ExtractGRPCErrorInfo(err) - Expect(info).NotTo(BeNil()) - Expect(info.Reason).To(Equal(domain.ErrReasonNumscriptNotFound)) - }) - - It("Should reject specifying both script and scriptReference", func() { - const txLedgerName = "numscript-lib-err-ledger" - - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", &servicepb.Request{ - Type: &servicepb.Request_Apply{ - Apply: &servicepb.LedgerApplyRequest{ - Ledger: txLedgerName, - Action: &servicepb.LedgerAction{Data: &servicepb.LedgerAction_CreateTransaction{ - CreateTransaction: &servicepb.CreateTransactionPayload{ - Script: &commonpb.Script{ - Plain: "send [USD/2 1] (source = @world destination = @x)", - }, - ScriptReference: &servicepb.ScriptReference{ - Name: "some-script", - }, - }, - }}, - }, - }, - })) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.InvalidArgument)) - }) - - It("Should create a numscript with version 'latest' when no version exists", func() { - resp, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptAction(ledgerName, "new-script", "send [USD/2 1] (source = @world destination = @x)"))) - Expect(err).To(Succeed()) - Expect(resp.Logs).To(HaveLen(1)) - - saved := resp.Logs[0].Payload.GetSavedNumscript() - Expect(saved).NotTo(BeNil()) - Expect(saved.Info.Name).To(Equal("new-script")) - Expect(saved.Info.Version).To(Equal("latest")) - - // Verify we can retrieve it - info, err := sharedClient.GetNumscript(sharedCtx, &servicepb.GetNumscriptRequest{ - Ledger: ledgerName, - Name: "new-script", - }) - Expect(err).To(Succeed()) - Expect(info.Version).To(Equal("latest")) - }) - - It("Should reject saving with invalid version format", func() { - _, err := sharedClient.Apply(sharedCtx, servicepb.UnsignedApplyRequest("", actions.SaveNumscriptWithVersionAction(ledgerName, "payment", "send [USD/2 1] (source = @world destination = @x)", "invalid"))) - Expect(err).To(HaveOccurred()) - st, ok := status.FromError(err) - Expect(ok).To(BeTrue()) - Expect(st.Code()).To(Equal(codes.InvalidArgument)) - - info := actions.ExtractGRPCErrorInfo(err) - Expect(info).NotTo(BeNil()) - Expect(info.Reason).To(Equal(domain.ErrReasonNumscriptInvalidVersion)) + Expect(resp.Logs).To(HaveLen(2)) + Expect(resp.Logs[1].Payload.GetApply()).NotTo(BeNil()) }) }) }) diff --git a/tests/e2e/cluster/prepared_query_ledger_cache_rotation_test.go b/tests/e2e/cluster/prepared_query_ledger_cache_rotation_test.go index d0069728d9..f7451caf9c 100644 --- a/tests/e2e/cluster/prepared_query_ledger_cache_rotation_test.go +++ b/tests/e2e/cluster/prepared_query_ledger_cache_rotation_test.go @@ -14,8 +14,8 @@ import ( . "github.com/onsi/gomega" ) -// numscriptTransfer is a minimal but valid Numscript used by the SaveNumscript / -// DeleteNumscript checks below. +// numscriptTransfer is a minimal but valid Numscript used by the SaveNumscript +// check below. const numscriptTransfer = ` vars { account $from @@ -147,21 +147,4 @@ var _ = Describe("Prepared query and numscript work after ledger cache eviction" })) Expect(err).To(Succeed()) }) - - It("DeleteNumscript must succeed after the LedgerInfo is evicted from cache", func() { - for i := 0; i < barrierCount; i++ { - _, err := client.Barrier(ctx, &servicepb.BarrierRequest{}) - Expect(err).To(Succeed()) - } - - _, err := client.Apply(ctx, servicepb.UnsignedApplyRequest("", &servicepb.Request{ - Type: &servicepb.Request_DeleteNumscript{ - DeleteNumscript: &servicepb.DeleteNumscriptRequest{ - Name: "transfer", - Ledger: ledgerName, - }, - }, - })) - Expect(err).To(Succeed()) - }) }) diff --git a/tests/e2e/testutil/helpers.go b/tests/e2e/testutil/helpers.go index 5c93b03c1a..07b48327d4 100644 --- a/tests/e2e/testutil/helpers.go +++ b/tests/e2e/testutil/helpers.go @@ -40,9 +40,7 @@ var ( CreateLedgerWithSchemaAction = actions.CreateLedgerWithSchemaAction SaveTypedAccountMetadataAction = actions.SaveTypedAccountMetadataAction SaveTypedTransactionMetadataAction = actions.SaveTypedTransactionMetadataAction - SaveNumscriptAction = actions.SaveNumscriptAction SaveNumscriptWithVersionAction = actions.SaveNumscriptWithVersionAction - DeleteNumscriptAction = actions.DeleteNumscriptAction CreateScriptRefTransactionAction = actions.CreateScriptRefTransactionAction CreateBuiltinTxIndexAction = actions.CreateBuiltinTxIndexAction DropBuiltinTxIndexAction = actions.DropBuiltinTxIndexAction diff --git a/tests/scenarios/marketplace/README.md b/tests/scenarios/marketplace/README.md index dbc1dc8db6..90960a51ae 100644 --- a/tests/scenarios/marketplace/README.md +++ b/tests/scenarios/marketplace/README.md @@ -110,9 +110,9 @@ All merchant balances verified at 0. - **Transaction reference**: `unique-ref-001` on a deposit; duplicate reference fails - **Idempotency key**: `ik-deposit-001` on a deposit; replay with same content succeeds (returns original); different content with same key fails -### Phase 11: DeleteNumscript +### Phase 11: Numscript versioning -- Save `temp_script`, then delete it +- Append immutable `temp_script` versions `1.0.0` then `2.0.0`; the latest pointer tracks the greatest ### Phase 11b: Prepared Queries diff --git a/tests/scenarios/marketplace/marketplace_test.go b/tests/scenarios/marketplace/marketplace_test.go index f3d27b03ae..12d15f9196 100644 --- a/tests/scenarios/marketplace/marketplace_test.go +++ b/tests/scenarios/marketplace/marketplace_test.go @@ -439,20 +439,21 @@ send $amount ( // idempotency key survives snapshot restore (regression test). expectedCustomer1BeforeRestart := new(big.Int).Set(customerBalance[1]) - // --- Phase 11: DeleteNumscript --- - t.Run("DeleteNumscript", func(t *testing.T) { - // Save a temporary script, then delete it - scenariotest.ApplyActions(t, ctx, client, - actions.SaveNumscriptWithVersionAction(ledger, "temp_script", `vars { + // --- Phase 11: Numscript versioning (immutable append-only) --- + t.Run("NumscriptVersioning", func(t *testing.T) { + script := `vars { monetary $amount } send $amount ( source = @world destination = @customer:1 -)`, "1.0.0"), +)` + // Append two immutable versions; the latest pointer tracks the greatest. + scenariotest.ApplyActions(t, ctx, client, + actions.SaveNumscriptWithVersionAction(ledger, "temp_script", script, "1.0.0"), ) scenariotest.ApplyActions(t, ctx, client, - actions.DeleteNumscriptAction(ledger, "temp_script"), + actions.SaveNumscriptWithVersionAction(ledger, "temp_script", script, "2.0.0"), ) })