@axorum/client 0.0.0-stage → 1.0.0

package/dist/refusal.js

@@ -0,0 +1,176 @@
+/**
+ * Reading why an intent was refused (contract 5.0.0).
+ *
+ * @packageDocumentation
+ */
+/**
+ * The refusal codes this version of the contract documents.
+ *
+ * - `forbidden_by_rule`: a forbid rule in the judging policy won and no permit overrode
+ *   it. `rule` names it.
+ * - `not_delegated`: a permit matched and its conditions held, but no delegation to the
+ *   acting agent covers it. `rule` names the highest-priority such permit.
+ * - `denied_by_default`: no rule permitted the action for this actor, so the policy's
+ *   default deny applied. No `rule`.
+ * - `reason_archived`: the refused record has been archived, so a replay cannot carry
+ *   the reason. No `rule`.
+ *
+ * An **open vocabulary**: a newer service may send a code this client has never heard
+ * of. Test with {@link isKnownRefusalCode}, and fall back to `explanation`.
+ */
+export const REFUSAL_CODES = [
+    "forbidden_by_rule",
+    "not_delegated",
+    "denied_by_default",
+    "reason_archived",
+];
+/** Whether `code` is one this version of the contract documents. */
+export function isKnownRefusalCode(code) {
+    return REFUSAL_CODES.includes(code);
+}
+/**
+ * What a guard literal tested, named by `Condition.kind` (contract 5.0.0). An open
+ * vocabulary, like {@link REFUSAL_CODES}.
+ */
+export const CONDITION_KINDS = [
+    "register_cap",
+    "counterparty_limit",
+    "mandate_cap",
+    "counterparty_list",
+    "chart_of_accounts",
+    "posting_period",
+    "posted_balance",
+    "time_window",
+    "actor",
+    "param",
+];
+/** Whether `kind` is one this version of the contract documents. */
+export function isKnownConditionKind(kind) {
+    return CONDITION_KINDS.includes(kind);
+}
+/**
+ * What a figure read, named by `Figure.source`: `register` carries `register`, `window`
+ * and `scope`; `mandate` carries `mandate` and `quantity`. An open vocabulary.
+ */
+export const FIGURE_SOURCES = ["register", "mandate"];
+/** The comparisons `Figure.op` can name, as the policy wrote them. An open vocabulary. */
+export const COMPARISON_OPS = ["eq", "ne", "lt", "le", "gt", "ge", "in"];
+/** The windows `Figure.window.kind` can name. An open vocabulary. */
+export const WINDOW_KINDS = ["rolling", "calendar", "unbounded"];
+/** The partitions `Figure.scope` can name. An open vocabulary. */
+export const REGISTER_SCOPES = [
+    "per_party",
+    "per_role",
+    "per_counterparty",
+    "per_rail",
+    "global",
+];
+/** The mandate quantities `Figure.quantity` can name. An open vocabulary. */
+export const MANDATE_QUANTITIES = ["spent", "ceiling", "remaining", "projected"];
+/** The modalities `SetAside.modality` can name. An open vocabulary. */
+export const MODALITIES = ["permitted", "obligated", "forbidden"];
+/**
+ * The figure a condition compared, or `undefined` when the literal compared no figure
+ * (a list membership, an actor test) or the index is out of range.
+ *
+ * Every amount on a figure is a `bigint` in minor units of `currency`: exact at any
+ * magnitude, including above 2^64. `exponent` is the deployment's declared scale.
+ *
+ * ```ts
+ * const refusal = refusalOf(outcome);
+ * for (const condition of refusal?.conditions ?? []) {
+ *   const figure = figureOf(refusal!, condition);
+ *   if (figure?.headroom !== undefined && figure.headroom > 0n) {
+ *     retryWith(figure.headroom); // the largest amount that clears this condition
+ *   }
+ * }
+ * ```
+ */
+export function figureOf(refusal, condition) {
+    if (condition.figure === undefined) {
+        return undefined;
+    }
+    const index = Number(condition.figure);
+    return Number.isSafeInteger(index) ? refusal.figures?.[index] : undefined;
+}
+/**
+ * The substrate laws a `substrate_rejected` error body can name in `law` (contract
+ * 5.0.0). Present only on a genuine law violation, never on malformed input. An open
+ * vocabulary, like {@link REFUSAL_CODES}.
+ */
+export const SUBSTRATE_LAWS = [
+    "conservative",
+    "authorization_conservation",
+    "revenue_cost_matching",
+    "usage_balance_conservation",
+    "period_close_roll_forward",
+];
+/** Whether `law` is one this version of the contract documents. */
+export function isKnownSubstrateLaw(law) {
+    return SUBSTRATE_LAWS.includes(law);
+}
+/**
+ * What the caller must change, named by `cause` on a `substrate_rejected` error body
+ * (contract 5.0.0). Present only when the refusal broke no law but the intent was
+ * malformed in a way the caller can fix; a body carries `law` or `cause`, never both.
+ * An open vocabulary, like {@link REFUSAL_CODES}.
+ *
+ * @example
+ * ```ts
+ * if (error.body.cause === "unknown_account") {
+ *   // provision the account, or post to one that exists
+ * }
+ * ```
+ */
+export const SUBSTRATE_CAUSES = [
+    "unknown_account",
+    "account_revoked",
+    "currency_mismatch",
+    "non_positive_amount",
+    "entry_count",
+    "amount_overflow",
+    "unknown_mandate",
+    "mandate_revoked",
+    "unknown_usage",
+    "usage_not_owned",
+    "unknown_deferral",
+    "unknown_counterparty",
+    "counterparty_mandate_unresolved",
+    "undeclared_action",
+    "missing_param",
+    "unexpected_param",
+    "param_type_mismatch",
+    "period_closed",
+    "undeclared_currency",
+];
+/** Whether `cause` is one this version of the contract documents. */
+export function isKnownSubstrateCause(cause) {
+    return SUBSTRATE_CAUSES.includes(cause);
+}
+/**
+ * Why `outcome` was refused, or `undefined` if it posted.
+ *
+ * Branch on `code`; for policy-specific reasons, branch on `rule.name`, which you
+ * declared. Show `explanation` to a human: it names the rule and says what to do next.
+ *
+ * `undefined` on a refused outcome means the service predates contract 5.0.0 and sent
+ * no reason; `posted: false` is still the refusal.
+ *
+ * The refusal is **not signed**. The receipt signs the provenance (whose `winning` is
+ * the rule id) and the policy hash; the refusal is derived from those, so a verifier
+ * recomputes it from signed facts rather than trusting these bytes.
+ *
+ * ```ts
+ * const outcome = await axorum.submitPinned(draft);
+ * const refusal = refusalOf(outcome);
+ * if (refusal?.code === "forbidden_by_rule" && refusal.rule?.name === "no_unapproved_vendors") {
+ *   await askForVendorApproval();
+ * } else if (refusal) {
+ *   console.log(refusal.explanation);
+ * }
+ * ```
+ */
+export function refusalOf(outcome) {
+    return outcome.posted ? undefined : outcome.refusal;
+}
+//# sourceMappingURL=refusal.js.map

package/dist/refusal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.js","sourceRoot":"","sources":["../src/refusal.ts"],"names":[],"mappings":"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"}

package/dist/retry.d.ts

@@ -0,0 +1,215 @@
+/**
+ * The transport retry policy: a mirror of `acton-service-client` 0.2's, which the Rust
+ * SDK uses, so both SDKs retry alike.
+ *
+ * Retries are **off** for a client's own calls unless it is built with a
+ * {@link RetryPolicy}. When one is, a request is sent again after a connection failure
+ * or a timeout, and after a `429`, `502` or `504` from something in front of the
+ * service (or a `423` that says when to come back), honouring `Retry-After`. A status
+ * the service documents as an answer (every `4xx` it sends, `421 not_primary`, `503
+ * commit_unavailable`) is not retried there: it reaches the caller after one send.
+ *
+ * `authorize` always retries, under its own policy ({@link AUTHORIZE_RETRY_POLICY}) and
+ * one deadline for the whole call ({@link AUTHORIZE_DEADLINE_MS}), and re-sends a `421`
+ * and a `503` too ({@link AUTHORIZE_RESENT_STATUSES}).
+ *
+ * Every function here is pure. `spec/fixtures/retry-v1.json` pins each one to the rows
+ * the Rust SDK pins `acton-service-client` itself to.
+ *
+ * @packageDocumentation
+ */
+/**
+ * How a retry pause is spread below its exponential ceiling.
+ *
+ * - `"none"`: every pause is exactly the ceiling.
+ * - `"full"`: uniform over `[baseDelayMs, ceiling]`, floored at `baseDelayMs`, so a
+ *   pause is never shorter than the base and a failing upstream is never hammered by a
+ *   run of near-zero pauses.
+ */
+export type Jitter = "none" | "full";
+/**
+ * Exponential backoff with a cap, optional jitter, and an optional total deadline.
+ * `maxAttempts` counts every send, the first included: `3` is one send and up to two
+ * retries. With a deadline, whichever of the two is reached first ends the loop.
+ */
+export interface RetryPolicy {
+    /** Sends in total, the first included. Below 1 behaves as 1. */
+    readonly maxAttempts: number;
+    /** The pause after the first send, in milliseconds, and the floor of every jittered one. */
+    readonly baseDelayMs: number;
+    /** The longest computed pause, in milliseconds. A `Retry-After` may exceed it. */
+    readonly maxDelayMs: number;
+    /**
+     * The whole call's budget, first send to last response, in milliseconds. Left out,
+     * the call is bounded by `maxAttempts` alone, and a `Retry-After` is honoured uncapped.
+     */
+    readonly deadlineMs?: number;
+    /** How each pause is spread below its ceiling. Defaults to `"none"`. */
+    readonly jitter?: Jitter;
+}
+/**
+ * Three sends, 100 ms doubling, capped at 5 s, no jitter, no deadline:
+ * `acton-service-client`'s default.
+ *
+ * ```ts
+ * import { AxorumClient, DEFAULT_RETRY_POLICY } from "@axorum/client";
+ *
+ * const axorum = new AxorumClient({ baseUrl, retry: DEFAULT_RETRY_POLICY });
+ * ```
+ */
+export declare const DEFAULT_RETRY_POLICY: RetryPolicy;
+/**
+ * The whole budget of one `authorize` call, in milliseconds: the window and pin reads,
+ * every submission, every attempt and every pause. The most `authorizeDeadlineMs`
+ * accepts, since the attestation minimum is sized for it.
+ */
+export declare const AUTHORIZE_DEADLINE_MS = 15000;
+/**
+ * The response header on `GET /api/openapi.json` in which a clustered service advertises
+ * its commit wait (`[cluster] submit_timeout_ms`), in milliseconds: how long it holds a
+ * submission before answering `503 commit_unavailable`. A standalone service has no
+ * commit wait and sends none.
+ */
+export declare const SUBMIT_TIMEOUT_HEADER = "axorum-submit-timeout-ms";
+/**
+ * How much longer than the advertised commit wait an attempt waits, in milliseconds, so
+ * the service's own `503 commit_unavailable` arrives before the client gives up.
+ */
+export declare const COMMIT_WAIT_MARGIN_MS = 1000;
+/**
+ * The most one attempt waits, in milliseconds, when the service advertises no commit
+ * wait: a standalone service, one older than the header, or an advertisement that could
+ * not be read. Also the bound on each of `authorize`'s reads.
+ */
+export declare const SUBMIT_ATTEMPT_FALLBACK_MS = 6000;
+/**
+ * The most one submission attempt waits against a service whose advertised commit wait
+ * is `commitWaitMs`: that wait plus {@link COMMIT_WAIT_MARGIN_MS}, or
+ * {@link SUBMIT_ATTEMPT_FALLBACK_MS} when none is advertised. Pure.
+ *
+ * Under `authorize`'s deadline the attempt is further clamped to what is left of it. When
+ * that clamp cuts an attempt below the commit wait plus the margin, the service may still
+ * be deciding when the client stops waiting, so an attempt that ends that way is honestly
+ * `indeterminate`: re-drive the same payment to learn its answer.
+ *
+ * ```ts
+ * submitAttemptTimeout(undefined); // 6000
+ * submitAttemptTimeout(9_000); // 10000
+ * ```
+ */
+export declare function submitAttemptTimeout(commitWaitMs: number | undefined): number;
+/**
+ * The timeout a plain submission needs in place of the SDK's default `defaultMs` to
+ * outlast an advertised `commitWaitMs`: {@link submitAttemptTimeout} of it, when that is
+ * longer. Never shorter, and `undefined` when no wait is advertised. Pure.
+ */
+export declare function liftedSubmitTimeout(defaultMs: number, commitWaitMs: number | undefined): number | undefined;
+/**
+ * The commit wait, in milliseconds, a {@link SUBMIT_TIMEOUT_HEADER} value states, or
+ * `undefined` when it states none: only 1 to 9 ASCII digits, not all zero, state a wait.
+ * Anything else (a sign, a space, an exponent, a tenth digit) is treated as no
+ * advertisement rather than guessed at, so this client reads the header as the Rust
+ * client does (`spec/fixtures/attempt-timeout-v1.json` pins both). Pure.
+ */
+export declare function advertisedCommitWait(value: string | null | undefined): number | undefined;
+/**
+ * The policy every `authorize` request is sent under: as many attempts as the deadline
+ * allows, full jitter floored at 100 ms, capped at 1.6 s. The deadline is not in it: it is
+ * an instant, set once per call and shared by all of its requests.
+ */
+export declare const AUTHORIZE_RETRY_POLICY: RetryPolicy;
+/**
+ * The status an `authorize` submission is re-sent on beyond the defaults: `421
+ * not_primary`, safe to re-send under the same transaction id. A `503` is not here: the
+ * transport re-sends on the status alone and reads no body, and only its body tells a
+ * `503 idempotency_unseeded`, which wrote nothing, from a `503 commit_unavailable`,
+ * which may have committed. So the call sends a `503` again itself, its body read.
+ */
+export declare const AUTHORIZE_RESENT_STATUSES: readonly number[];
+/**
+ * The exponential ceiling for the pause after send number `attempt` (1-based):
+ * `baseDelayMs × 2^(attempt − 1)`, capped at `maxDelayMs`. An attempt below 1 is
+ * treated as 1; a huge one saturates to the cap. With no jitter it is the pause. Pure.
+ */
+export declare function backoffDelay(policy: RetryPolicy, attempt: number): number;
+/**
+ * The pause after send number `attempt` (1-based), or `undefined` when it would reach the
+ * deadline. Pure.
+ *
+ * - `draw` is a uniform sample, clamped to `[0, 1)`; a `NaN` counts as 0. Ignored
+ *   without jitter.
+ * - `remainingMs` is the time left before the deadline, or `undefined` for none.
+ *
+ * With `ceiling = backoffDelay(policy, attempt)` and `floor = min(baseDelayMs, ceiling)`:
+ * no jitter pauses `ceiling`; full jitter pauses `floor + ⌊(ceiling − floor) × draw⌋`.
+ * Either is refused when `remainingMs` is set and the pause is at least it.
+ */
+export declare function pause(policy: RetryPolicy, attempt: number, draw: number, remainingMs: number | undefined): number | undefined;
+/** Whether another send is allowed after send number `attempt` (1-based). Pure. */
+export declare function shouldRetry(policy: RetryPolicy, attempt: number): boolean;
+/**
+ * The pause before the send after `attempt`, or `undefined` to stop: when `maxAttempts`
+ * is spent, or when the pause would reach the deadline. A server's `Retry-After`
+ * replaces the computed pause (unjittered, not capped by `maxDelayMs`) but is still
+ * refused if it would reach the deadline. Pure.
+ */
+export declare function nextPause(policy: RetryPolicy, attempt: number, draw: number, retryAfterMs: number | undefined, remainingMs: number | undefined): number | undefined;
+/**
+ * The timeout for one send, or `undefined` to leave the client's own. Pure.
+ *
+ * In order: the request's own, the client-wide attempt timeout, then (under a deadline
+ * only) the client's timeout, then the time remaining; under a deadline, whichever
+ * applies is clamped to what remains.
+ */
+export declare function attemptTimeout(requestMs: number | undefined, clientAttemptMs: number | undefined, clientMs: number | undefined, remainingMs: number | undefined): number | undefined;
+/**
+ * Whether a failing `status` asks for another send. A status listed in `retryOn` always
+ * does, checked first; otherwise an accepted (documented) status never does, and any
+ * other does when {@link isRetriableStatus} says so. Pure.
+ */
+export declare function wantsRetry(status: number, hasRetryAfter: boolean, accepted: boolean, retryOn: readonly number[]): boolean;
+/**
+ * Whether a failing status is worth another send: `429`, `502`, `503`, `504`, and `423`
+ * only when the server said when to come back. Pure.
+ */
+export declare function isRetriableStatus(status: number, hasRetryAfter: boolean): boolean;
+/**
+ * How an attempt that is about to be sent again ended: the counterpart of
+ * `acton-service-client`'s `RetryReason`.
+ */
+export type RetryReason = {
+    readonly kind: "connect";
+} | {
+    readonly kind: "timeout";
+} | {
+    readonly kind: "status";
+    readonly status: number;
+};
+/** A reason's label, as the Rust SDK's `RetryReason::label` spells it: `"503"`, `"timeout"`. Pure. */
+export declare function retryLabel(reason: RetryReason): string;
+/**
+ * The pause, if it ends strictly before the deadline `remainingMs` away, or `undefined`
+ * when it would reach it: `acton-service-client`'s rule, the boundary included. With no
+ * deadline every pause fits. Pure.
+ */
+export declare function fitsBefore(pauseMs: number, remainingMs: number | undefined): number | undefined;
+/**
+ * A `Retry-After` header's delay in milliseconds, or `undefined`. Only the
+ * delta-seconds form is read, as Rust parses a `u64`: an optional `+`, then digits. An
+ * HTTP date, a fraction, a minus sign or an overflow is ignored. Pure.
+ */
+export declare function parseRetryAfter(header: string | null): number | undefined;
+/**
+ * Rejects a policy whose counts and delays are not non-negative whole numbers, whose
+ * deadline is not a positive whole number, or whose jitter is not one this SDK knows.
+ *
+ * @throws {RangeError} Naming the bad field.
+ */
+export declare function checkRetryPolicy(policy: RetryPolicy): void;
+/**
+ * Whether a `fetch` rejection is a connection that never opened: the counterpart of
+ * reqwest's `is_connect`, which is what `acton-service-client` retries (with timeouts).
+ * A connection that broke after the request went out is not one. Pure.
+ */
+export declare function isConnectFailure(error: unknown): boolean;
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry.d.ts","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":"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"}