@0xmonaco/types 1.0.58 → 1.0.59

package/dist/wire/schema.d.ts

@@ -585,8 +585,21 @@ export interface paths {
          * @description Create authentication challenge.
          *
          *      Generate a cryptographic challenge (nonce) for wallet-based authentication.
-         *      The user must sign the returned message with their private key to prove
-         *      ownership of the wallet.
+         *      The wallet must authorize the returned message to prove control of the
+         *      address. An EOA does that by signing it with its private key. A
+         *      smart-contract wallet has no private key and instead produces a signature
+         *      its own contract will accept, which Monaco checks under EIP-1271 — see
+         *      Verify.
+         *
+         *      The challenge is single-use and binds the session public key supplied here,
+         *      so it authorizes exactly one keypair, once. The lifetime is 5 minutes, or
+         *      30 minutes for EVERY address while contract-signature login is enabled on
+         *      the deployment — a multisig must collect owner approvals before it can
+         *      answer, and the window is uniform rather than eligibility-specific so this
+         *      unauthenticated endpoint cannot be used to probe which addresses hold a
+         *      BuilderCodes payout bucket. Widening it is cheap: a longer window is a
+         *      longer-lived offer to authorize one predetermined keypair once, never a
+         *      longer-lived credential.
          */
         post: operations["create_challenge"];
         delete?: never;
@@ -659,6 +672,30 @@ export interface paths {
          *      Verify the signed challenge message and create an authenticated session.
          *      Binds the caller-provided ed25519 session public key to the new session;
          *      subsequent requests are signed with the matching private key.
+         *
+         *      How the signature is checked depends on the address. Almost every address
+         *      is verified by recovering the signing key, exactly as before. EIP-1271
+         *      verification applies only to an address that is BOTH eligible for
+         *      contract-signature login AND has contract code deployed on chain: an
+         *      eligible payout wallet that is an ordinary EOA is still verified by
+         *      recovery. The two are mutually exclusive, and the request is identical
+         *      either way — `signature` carries whatever the wallet produced, and no
+         *      field changes. The one bound is length: a contract signature over 8192
+         *      decoded bytes is refused as invalid rather than forwarded to the chain,
+         *      which is far above any realistic owner set.
+         *
+         *      Because deciding that requires reading the chain, this adds one
+         *      client-visible outcome the recovery path does not have: UNAVAILABLE (REST
+         *      503). It is retryable and is NOT a verdict on the signature. It covers
+         *      three cases, and an eligible address can see any of them even when it turns
+         *      out to be an EOA, because the code lookup happens first: the chain did not
+         *      answer, it did not answer within the deadline, or the server declined to
+         *      ask because its own concurrent-verification capacity was full. That last
+         *      one is local saturation rather than a chain fault, so an operator
+         *      diagnosing it should check this service before the RPC endpoint.
+         *
+         *      A rejected signature is 401, and so is a contract that rejects by
+         *      REVERTING: that is the wallet answering "no", not a failure to ask.
          */
         post: operations["verify_signature"];
         delete?: never;
@@ -667,6 +704,180 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/api/v1/buildercodes/config": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your BuilderCodes program configuration
+         * @description Read this application's BuilderCodes program state.
+         *
+         *      The application is taken from the authenticated session; there is no
+         *      application id in the request. The caller must be the application's
+         *      configured payout wallet. This method is gated by `buildercodes_enabled`
+         *      like the rest of the service.
+         */
+        get: operations["get_buildercodes_config"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/buildercodes/payouts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List your per-trade BuilderCodes earnings
+         * @description List this application's per-trade BuilderCodes earnings.
+         *
+         *      Newest credits are returned first. The application is taken from the
+         *      authenticated session and cannot be selected by the caller.
+         */
+        get: operations["list_buildercode_payouts"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/buildercodes/payouts/summary": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Summarize your BuilderCodes earnings
+         * @description Summarize this application's BuilderCodes earnings by token.
+         *
+         *      Amounts stay separated by token because they are RAW atomic units. The
+         *      application is taken from the authenticated session.
+         */
+        get: operations["get_buildercode_payout_summary"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/buildercodes/rewards/balance": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Get your accrued BuilderCodes balance
+         * @description Read the caller's accrued BuilderCodes reward-bucket balances.
+         *
+         *      The bucket is derived from the authenticated wallet under the reserved
+         *      BuilderCodes application. Current enrollment is not required, so a former
+         *      payout wallet can still inspect and claim what it accrued. Returns an empty
+         *      list when no payout bucket or non-zero balance exists.
+         */
+        get: operations["get_buildercode_rewards_balance"];
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/api/v1/buildercodes/rewards/claim": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Claim accrued BuilderCodes payout balance
+         * @description Claim accrued BuilderCodes payout balance.
+         *
+         *      Move accrued BuilderCodes payout balance from your reserved payout bucket
+         *      into a trading balance under the authenticated application, making it
+         *      withdrawable through the ordinary withdrawal flow. Ledger-only (one shared
+         *      vault + one backend ledger) — no on-chain transaction and no gas.
+         *
+         *      The bucket is resolved from the AUTHENTICATED caller's own wallet address,
+         *      never from the request body, so a caller can only ever claim their own
+         *      accrued balance. A wallet that has never been an enrolled frontend's payout
+         *      address simply has an empty bucket. A wallet that USED to be a payout
+         *      address keeps whatever it accrued back then and can still claim it —
+         *      payout-address changes are not retroactive, so current enrollment is
+         *      deliberately not required.
+         *
+         *      The payout wallet may be an EOA or a smart-contract wallet. An EOA answers
+         *      Monaco's signature challenge directly. A contract wallet — a multisig such
+         *      as a Safe — holds no private key and cannot, so it authenticates by EIP-1271
+         *      contract signature instead: Monaco asks the wallet contract whether it
+         *      accepts the challenge. That path is deliberately narrow. It is offered only
+         *      to a wallet that holds a BuilderCodes payout bucket, only while the
+         *      `contract_wallet_auth_enabled` flag is on, and only where the deployment has
+         *      a chain RPC endpoint configured. While any of those is not met, login is
+         *      EOA-only and a contract payout wallet can neither call this endpoint nor
+         *      withdraw afterwards, so its accrued share stays unclaimable.
+         *
+         *      Delegated-agent sessions are refused: a delegated grant conveys only
+         *      order-management authority, and this claim converts reserved balance into a
+         *      tradeable one. The refusal happens before the feature check, so a delegated
+         *      caller is refused whether or not BuilderCodes is enabled.
+         *
+         *      Transport contracts differ, and this comment is emitted into the generated
+         *      gRPC SDK where HTTP statuses do not exist. An insufficient payout balance
+         *      is **HTTP 409** on REST and **FAILED_PRECONDITION** on gRPC; a refused
+         *      caller (delegated session, or BuilderCodes disabled) is **HTTP 403** on
+         *      REST and **PERMISSION_DENIED** on gRPC.
+         *
+         *      A claim can also fail as **HTTP 503** / **UNAVAILABLE** when the matching
+         *      engine is unreachable, restarting, or slow to answer. Treat that as an
+         *      UNKNOWN outcome, NOT a rejection. The request is admitted to the sequencer
+         *      before its reply is sent, so a claim that timed out in transit may still
+         *      commit, and there is no idempotency key — a blind retry can claim a SECOND
+         *      time. Do NOT retry automatically, and do not settle it with a balance
+         *      read: an admitted claim can still be sitting in the sequencer queue when
+         *      the balance is read, so an unchanged balance does not prove the claim will
+         *      not commit. Treat the claim as PENDING rather than failed, re-check once
+         *      the engine is healthy again, and reconcile before issuing another claim.
+         *
+         *      Not every 503 is ambiguous, and the safe ones are tagged. TWO outcomes are
+         *      refused BEFORE the claim can be admitted to the sequencer, so they left no
+         *      durable-log or state footprint and definitely committed nothing. One is a
+         *      deliberate maintenance block, where REST carries
+         *      `"error": "OPERATIONS_BLOCKED"` and gRPC tags the status with
+         *      `x-maintenance-blocked: true`. The other is a sequencer admission rejection
+         *      when the engine is saturated, where REST carries `"code": "OVERLOADED"` and
+         *      gRPC carries the same code in the status' error details. Both are safe to
+         *      retry with backoff, and an overload positively wants one. Only an UNTAGGED
+         *      availability failure — matching-engine transport, timeout and fail-closed
+         *      paths — carries the unknown outcome.
+         */
+        post: operations["claim_buildercode_rewards"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/api/v1/delegated-agents": {
         parameters: {
             query?: never;
@@ -3042,6 +3253,73 @@ export interface components {
             matchResult?: components["schemas"]["MatchResult"];
             error?: components["schemas"]["BatchReplaceError"];
         };
+        BuildercodePayout: {
+            /**
+             * Format: uuid
+             * @description Trade that generated this credit.
+             */
+            tradeId?: string | null;
+            /**
+             * @description Application payout address at credit time.
+             * @example 0x0000000000000000000000000000000000000001
+             */
+            payoutAddress?: string | null;
+            /**
+             * @description Credit token contract address.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token?: string | null;
+            /**
+             * @description Credited amount in RAW atomic units of the token.
+             * @example 1000000
+             */
+            amount?: string | null;
+            /**
+             * Format: int32
+             * @description Realized whole-basis-point rate for this credit after the Monaco-floor clamp, computed from the credited amount divided by the gross protocol take and truncated down. This can be lower than the configured BuilderCodes budget.
+             * @example 1000
+             */
+            appliedBps?: number | null;
+            /**
+             * Format: date-time
+             * @description RFC 3339 credit timestamp.
+             */
+            createdAt?: string | null;
+        };
+        BuildercodePayoutTokenTotal: {
+            /**
+             * @description Credit token contract address.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token?: string | null;
+            /**
+             * @description Summed credits in RAW atomic units of this token.
+             * @example 5000000
+             */
+            totalAmount?: string | null;
+            /**
+             * Format: int64
+             * @description Number of credits included in this token total.
+             */
+            payoutCount?: number | null;
+            /**
+             * Format: date-time
+             * @description RFC 3339 timestamp of this token's newest credit.
+             */
+            lastCreditedAt?: string | null;
+        };
+        BuildercodeRewardsBalance: {
+            /**
+             * @description Reward token contract address.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token?: string | null;
+            /**
+             * @description Available BuilderCodes reward balance in RAW atomic units.
+             * @example 1200000
+             */
+            available?: string | null;
+        };
         CancelConditionalOrderResponse: {
             /**
              * Format: uuid
@@ -3217,6 +3495,30 @@ export interface components {
              */
             reason?: string | null;
         };
+        ClaimBuildercodeRewardsRequest: {
+            /**
+             * @description Payout token contract address (0x-prefixed) to claim. BuilderCodes shares accrue in the quote token of the traded pair.
+             * @example 0x0000000000000000000000000000000000000002
+             */
+            token: string;
+            /**
+             * @description Amount to claim, in RAW atomic units of the token. Must be positive and no greater than the accrued payout balance.
+             * @example 1000000
+             */
+            amount: string;
+        };
+        ClaimBuildercodeRewardsResponse: {
+            /**
+             * @description Your BuilderCodes payout-bucket balance after the claim, RAW atomic units.
+             * @example 0
+             */
+            payoutBalance?: string | null;
+            /**
+             * @description Your trading balance for the token after the claim, RAW atomic units.
+             * @example 1000000
+             */
+            tradingBalance?: string | null;
+        };
         ClosePositionRequest: {
             quantity?: string | null;
             closeType?: string | null;
@@ -4061,6 +4363,46 @@ export interface components {
              */
             totalPages?: number | null;
         };
+        GetBuildercodePayoutSummaryResponse: {
+            /**
+             * Format: int64
+             * @description Total credit count across every token.
+             */
+            totalPayouts?: number | null;
+            /**
+             * Format: date-time
+             * @description RFC 3339 timestamp of the newest credit, or null when none exists.
+             */
+            lastCreditedAt?: string | null;
+            /** @description Per-token earnings totals. Empty when this application has no payouts. */
+            byToken?: components["schemas"]["BuildercodePayoutTokenTotal"][] | null;
+        };
+        GetBuildercodeRewardsBalanceResponse: {
+            /** @description One entry per reward token with a non-zero available balance. */
+            balances?: components["schemas"]["BuildercodeRewardsBalance"][] | null;
+        };
+        GetBuildercodesConfigResponse: {
+            /**
+             * Format: uuid
+             * @description Application id derived from the authenticated session.
+             */
+            applicationId?: string | null;
+            /** @description Whether this application is currently enrolled in BuilderCodes. */
+            enrolled?: boolean | null;
+            /**
+             * @description Current lowercase-normalized payout address, or null when none is configured.
+             * @example 0x0000000000000000000000000000000000000001
+             */
+            payoutAddress?: string | null;
+            /** @description Current BuilderCodes feature-flag state. Successful responses are true because this endpoint is gated by the flag. */
+            buildercodesEnabled?: boolean | null;
+            /**
+             * Format: uint32
+             * @description Target BuilderCodes share in basis points, computed from the fill's gross non-negative Monaco protocol take and capped by the remainder after Monaco's floor.
+             * @example 1000
+             */
+            buildercodesBudgetBps?: number | null;
+        };
         /** @description OHLCV candlestick data. */
         GetCandlesResponse: {
             candles?: components["schemas"]["Candle"][] | null;
@@ -4979,6 +5321,30 @@ export interface components {
              */
             liquidationPrice?: string | null;
             status?: string | null;
+            /**
+             * @description RFC 3339 instant at which this position was last MUTATED — a fill,
+             *      collateral transfer, funding settlement or close — as the producer that
+             *      owns the position recorded it. It is NOT the instant the response was
+             *      built: polling an unchanged position returns the same value, and an oracle
+             *      reprice does not move it. For an OPEN position every surface reports the
+             *      same instant — the list, the detail read, the risk read, the WebSocket
+             *      positions snapshot, and the live position_update frames.
+             *
+             *      Two cases come from the persistence clock instead and differ from the
+             *      matching engine's by the persistence lag: a TERMINAL row (the live
+             *      position_update frame carries the engine's close instant, this field
+             *      carries the stored one), and any position read after a matching-engine
+             *      restart. Accurate to that lag, not to the microsecond.
+             *
+             *      A third case is not lag-bounded: an OPEN row read while the matching
+             *      engine is unreachable falls back to the row's own lifecycle columns
+             *      (close, then last funding, then open), so a position filled repeatedly
+             *      since it opened reports its opening instant until funding settles. The
+             *      live position_update frame is unaffected.
+             *
+             *      Display metadata. `version` is the reconciliation key; ordering position
+             *      state by this field is never correct.
+             */
             updatedAt?: string | null;
             riskBucketId?: string | null;
             marginMode?: string | null;
@@ -5030,6 +5396,12 @@ export interface components {
              *      partial.
              */
             cumFees?: string | null;
+            /**
+             * Format: int64
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @example 918342
+             */
+            version?: number | null;
         };
         GetPositionRiskResponse: {
             positionId?: string | null;
@@ -5066,6 +5438,30 @@ export interface components {
              *      position has no open exposure.
              */
             initialMarginRequired?: string | null;
+            /**
+             * @description RFC 3339 instant at which this position was last MUTATED — a fill,
+             *      collateral transfer, funding settlement or close — as the producer that
+             *      owns the position recorded it. It is NOT the instant the response was
+             *      built: polling an unchanged position returns the same value, and an oracle
+             *      reprice does not move it. For an OPEN position every surface reports the
+             *      same instant — the list, the detail read, the risk read, the WebSocket
+             *      positions snapshot, and the live position_update frames.
+             *
+             *      Two cases come from the persistence clock instead and differ from the
+             *      matching engine's by the persistence lag: a TERMINAL row (the live
+             *      position_update frame carries the engine's close instant, this field
+             *      carries the stored one), and any position read after a matching-engine
+             *      restart. Accurate to that lag, not to the microsecond.
+             *
+             *      A third case is not lag-bounded: an OPEN row read while the matching
+             *      engine is unreachable falls back to the row's own lifecycle columns
+             *      (close, then last funding, then open), so a position filled repeatedly
+             *      since it opened reports its opening instant until funding settles. The
+             *      live position_update frame is unaffected.
+             *
+             *      Display metadata. `version` is the reconciliation key; ordering position
+             *      state by this field is never correct.
+             */
             updatedAt?: string | null;
         };
         GetProfileResponse: {
@@ -5623,6 +6019,30 @@ export interface components {
              */
             totalPages?: number | null;
         };
+        ListBuildercodePayoutsResponse: {
+            /** @description Per-trade credits, newest first. */
+            payouts?: components["schemas"]["BuildercodePayout"][] | null;
+            /**
+             * Format: uint32
+             * @description Total payout rows for this application.
+             */
+            total?: number | null;
+            /**
+             * Format: uint32
+             * @description Current page number.
+             */
+            page?: number | null;
+            /**
+             * Format: uint32
+             * @description Items per page.
+             */
+            pageSize?: number | null;
+            /**
+             * Format: uint32
+             * @description Total number of pages.
+             */
+            totalPages?: number | null;
+        };
         ListConditionalOrdersResponse: {
             orders?: components["schemas"]["ConditionalOrder"][] | null;
             /** Format: uint32 */
@@ -6457,6 +6877,30 @@ export interface components {
              */
             liquidationPrice?: string | null;
             status?: string | null;
+            /**
+             * @description RFC 3339 instant at which this position was last MUTATED — a fill,
+             *      collateral transfer, funding settlement or close — as the producer that
+             *      owns the position recorded it. It is NOT the instant the response was
+             *      built: polling an unchanged position returns the same value, and an oracle
+             *      reprice does not move it. For an OPEN position every surface reports the
+             *      same instant — the list, the detail read, the risk read, the WebSocket
+             *      positions snapshot, and the live position_update frames.
+             *
+             *      Two cases come from the persistence clock instead and differ from the
+             *      matching engine's by the persistence lag: a TERMINAL row (the live
+             *      position_update frame carries the engine's close instant, this field
+             *      carries the stored one), and any position read after a matching-engine
+             *      restart. Accurate to that lag, not to the microsecond.
+             *
+             *      A third case is not lag-bounded: an OPEN row read while the matching
+             *      engine is unreachable falls back to the row's own lifecycle columns
+             *      (close, then last funding, then open), so a position filled repeatedly
+             *      since it opened reports its opening instant until funding settles. The
+             *      live position_update frame is unaffected.
+             *
+             *      Display metadata. `version` is the reconciliation key; ordering position
+             *      state by this field is never correct.
+             */
             updatedAt?: string | null;
             riskBucketId?: string | null;
             marginMode?: string | null;
@@ -6508,6 +6952,12 @@ export interface components {
              *      partial.
              */
             cumFees?: string | null;
+            /**
+             * Format: int64
+             * @description Opaque, non-negative producer-owned version for this position row. Compare only within the same position; higher is newer. 0 is the unranked legacy sentinel and never participates in ordering: it means the row predates this field or came from a producer that does not stamp it, so treat it exactly as an absent version and fall back to a full field comparison rather than ranking it as oldest. It advances on sequenced position mutations (open, add, reduce, close, funding, margin transfer, liquidation, ADL) and is shared by the persisted read, the WebSocket positions snapshot and a RANKED live position_update frame. A live frame is ranked only when it is a faithful projection of the row persisted at that sequence: in practice the fills that leave a position open. Frames that re-read live risk state after sequencing (funding, margin_added/margin_reduced) and terminal frames (which report size 0 and LIQUIDATED, while the stored row keeps its size and records CLOSED) omit the version even though the mutation did advance the persisted one, so an absent version never implies that nothing was persisted. mark_price, unrealized_pnl, liquidation_price, leverage, maintenance_margin_required and initial_margin_required are UNVERSIONED valuation fields, re-derived per payload rather than served from the versioned row: the version does not advance for them (five move with the oracle mark; leverage does not, being opening notional over posted margin, but the live surfaces derive it while the persisted row serves its stored column, so it can still disagree at an unchanged version) (a valuation-only oracle tick persists nothing; a state-transitioning one, a breach or recovery, does restamp the account's open positions), so the merge rule is per field group — on an equal version skip the versioned fields but still take all six from the newer payload, because discarding a whole payload on an equal version freezes displayed PnL and can leave a stale margin requirement on screen. isolated_margin is the one exception among the versioned fields: the WebSocket positions snapshot overlays it from an independent live matching-engine read rather than the versioned row, so take it from the newest payload on an equal version too or a consumer can retain stale backing. A response served from live matching-engine state reports 0 (unranked): the engine holds the state but not the version.
+             * @example 918342
+             */
+            version?: number | null;
         };
         PositionHistoryEvent: {
             id?: string | null;
@@ -8052,7 +8502,7 @@ export interface components {
              */
             address: string;
             /**
-             * @description Wallet signature over the challenge message
+             * @description Wallet authorization of the challenge message, hex with an optional 0x prefix. An EOA sends a 65-byte EIP-191 signature; a contract wallet verified under EIP-1271 sends whatever its own contract accepts, which is usually longer and need not be 65 bytes. Capped at 8192 decoded bytes (16386 characters with the prefix) — enough for well over a hundred owner slots — and a longer value is rejected as an invalid signature rather than forwarded to the chain.
              * @example 0x1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6c7d8e9f0
              */
             signature: string;
@@ -9618,6 +10068,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Authentication rate limit exceeded — challenge and verify share one per-client-address budget (60 requests/min sustained, burst 120); retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -9774,6 +10231,13 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Authentication rate limit exceeded — challenge and verify share one per-client-address budget (60 requests/min sustained, burst 120), checked before the signature; retry after the interval in details.retryAfter */
+            429: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
             /** @description Internal server error */
             500: {
                 headers: {
@@ -9781,6 +10245,276 @@ export interface operations {
                 };
                 content?: never;
             };
+            /** @description Contract-wallet (EIP-1271) verification could not be completed for an eligible address: the chain did not answer, did not answer within the deadline, or the server was at its concurrent-verification capacity and declined to ask. Retryable, and not a verdict on the signature. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_buildercodes_config: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetBuildercodesConfigResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authenticated application not found (gRPC: NOT_FOUND) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    list_buildercode_payouts: {
+        parameters: {
+            query?: {
+                /** @description Page number (1-indexed) */
+                page?: number;
+                /** @description Items per page (max 100) */
+                pageSize?: number;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ListBuildercodePayoutsResponse"];
+                };
+            };
+            /** @description Invalid pagination */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authenticated application not found (gRPC: NOT_FOUND) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_buildercode_payout_summary: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetBuildercodePayoutSummaryResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused: BuilderCodes is disabled, the caller is delegated, or the caller is not this application's payout wallet (gRPC: PERMISSION_DENIED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authenticated application not found (gRPC: NOT_FOUND) */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    get_buildercode_rewards_balance: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["GetBuildercodeRewardsBalanceResponse"];
+                };
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused: BuilderCodes is disabled or the caller is delegated (gRPC: PERMISSION_DENIED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+        };
+    };
+    claim_buildercode_rewards: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": components["schemas"]["ClaimBuildercodeRewardsRequest"];
+            };
+        };
+        responses: {
+            /** @description OK */
+            200: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["ClaimBuildercodeRewardsResponse"];
+                };
+            };
+            /** @description Invalid token or amount */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Authentication required */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Refused: BuilderCodes is not enabled, or the caller is a delegated-agent session (gRPC: PERMISSION_DENIED) */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Insufficient BuilderCodes payout balance, including a wallet that never accrued one (gRPC: FAILED_PRECONDITION) */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Internal server error */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Matching engine unavailable or slow to answer. Outcome UNKNOWN, not a rejection — the claim may still commit and there is no idempotency key, so treat it as pending and do not retry automatically; a balance read does not settle it, because an admitted claim may still be queued. Two tagged cases are the exception, both refused before the claim can be admitted and so provably non-committing, and both safe to retry: a maintenance block (`error: OPERATIONS_BLOCKED`; gRPC metadata `x-maintenance-blocked: true`) and a sequencer overload (`code: OVERLOADED`) (gRPC: UNAVAILABLE) */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
         };
     };
     list_delegated_agents: {