@x1id/resolve 0.23.0 → 0.43.0

package/dist/subscription.d.ts

@@ -0,0 +1,439 @@
+/**
+ * X1ID Pay, phase 2: SPL pull subscriptions (docs/specs/x1id-pay-onchain.md
+ * §3/§4).
+ *
+ * - `Subscription` at `["sub", payer, payee, id]`: created and paid for by
+ *   the PAYER, its terms (mint, decimals, amount, period, max charges, the
+ *   optional `@name` binding) fixed for life. Any change = a new id.
+ * - The payer's delegate PDA `["sub_delegate", payer]` is the SPL delegate on
+ *   the payer's canonical ATA. ONE per payer (an SPL account has a single
+ *   delegate), so the SPL approval is shared by every subscription of that
+ *   payer in a mint. The program tracks each subscription's own share in
+ *   `allowanceLeft` (layout v2, Sentinel run-011): a charge needs and spends
+ *   `amount` of it, so no subscription can spend another's share.
+ * - The payer's `SubLedger` at `["sub_ledger", payer, mint]` (Sentinel S-01)
+ *   holds the running total of the Active shares in that mint. It is created
+ *   on first use by `create_subscription` (payer-funded, 82 bytes) and is
+ *   passed to every subscription instruction except close.
+ * - `create_subscription` records `amount × min(charges left, 12)` as the new
+ *   subscription's `allowanceLeft`, adds it to the ledger and SETS the SPL
+ *   approval to the new ledger total (not "current + window"), so an outside
+ *   revoke / approve or a re-created ATA can never leave a share unbacked
+ *   while another subscription spends it. An unlimited (or > 12-charge)
+ *   subscription needs a top-up after 12 charges:
+ *   {@link buildTopUpSubscriptionIx} (raises the share and the ledger, then
+ *   re-approves the ledger total; a plain SPL `Approve` alone does not extend
+ *   a subscription).
+ * - Any cancel (payer or payee) removes the subscription's `allowanceLeft`
+ *   from the ledger. A payer cancel with `giveBack` also re-approves
+ *   `min(current approval, remaining ledger total)` (Revoke at 0).
+ * - `charge_subscription` is a permissionless crank with NO arguments: it
+ *   pulls exactly `amount` once `now >= next_due_at` (fee to the treasury as
+ *   `pay_invoice`), then moves `next_due_at` to the next slot of the
+ *   creation-anchored schedule after `now` ({@link subNextDueAt}).
+ * - SPL Token and Token-2022 only; native XNT is not pullable (use invoices).
+ *   Token-2022 mints must carry only {@link SUB_ALLOWED_MINT_EXTENSIONS}.
+ *
+ * Routed through the program's `fallback` (`extra_ix`) like the rest of Pay:
+ * `sha256("global:<name>")[..8]` + raw Borsh, accounts in exactly the order of
+ * the program's `Accounts` structs. Hand-rolled, no web3.js.
+ */
+import type { AddressLike, BuiltInstruction } from "./delegate.js";
+import type { RpcFn } from "./accounts.js";
+import type { PdaFinder } from "./namespacePricing.js";
+import type { InvoiceHandleBinding } from "./pay.js";
+export declare const SUBSCRIPTION_SEED = "sub";
+export declare const SUB_DELEGATE_SEED = "sub_delegate";
+/** The payer's per-mint ledger: `["sub_ledger", payer, mint]`. */
+export declare const SUB_LEDGER_SEED = "sub_ledger";
+/** Allocated size of a `SubLedger` (8-byte discriminator + 74). */
+export declare const SUB_LEDGER_ACCOUNT_LEN: number;
+/** Current `SubLedger.version`. */
+export declare const SUB_LEDGER_VERSION = 1;
+/** Length of a subscription id (`[u8; 16]`). */
+export declare const SUBSCRIPTION_ID_LEN = 16;
+/** Allocated size of a `Subscription` (8-byte discriminator + `INIT_SPACE`;
+ *  238 since layout v2 added `allowance_left`). */
+export declare const SUBSCRIPTION_ACCOUNT_LEN: number;
+/** Current `Subscription.version`: 2 added `allowance_left`; 3 (same bytes)
+ *  marks a subscription counted in its payer's `SubLedger`. A v2 account is
+ *  refused by `charge_subscription` until a payer top-up adopts it. */
+export declare const SUBSCRIPTION_VERSION = 3;
+/** Shortest / longest billing period, seconds (1 hour / 5 × 366 days). */
+export declare const SUB_PERIOD_MIN_SECS = 3600n;
+export declare const SUB_PERIOD_MAX_SECS: bigint;
+/** Charges' worth of allowance `create_subscription` approves (and records
+ *  as the subscription's `allowanceLeft`) at most. */
+export declare const SUB_APPROVE_WINDOW_CHARGES = 12n;
+/** Token-2022 mint extension types a subscription mint may carry. */
+export declare const SUB_ALLOWED_MINT_EXTENSIONS: readonly number[];
+/** Byte offsets inside a raw `Subscription`, for `getProgramAccounts`
+ *  `memcmp` filters. Fields before the variable-width `handle` are fixed. */
+export declare const SUBSCRIPTION_OFFSETS: {
+    readonly version: 8;
+    readonly payer: 9;
+    readonly payee: 41;
+    readonly id: 73;
+    readonly mint: 89;
+    readonly decimals: 121;
+    readonly amount: 122;
+    readonly periodSecs: 130;
+    readonly nextDueAt: 138;
+    readonly maxCharges: 146;
+    readonly chargesMade: 150;
+    readonly status: 154;
+    readonly createdAt: 155;
+    readonly lastChargedAt: 163;
+    readonly handle: 171;
+};
+/** `sha256("global:create_subscription")[..8]`. */
+export declare const CREATE_SUBSCRIPTION_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:charge_subscription")[..8]`. */
+export declare const CHARGE_SUBSCRIPTION_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:cancel_subscription")[..8]`. */
+export declare const CANCEL_SUBSCRIPTION_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:close_subscription")[..8]`. */
+export declare const CLOSE_SUBSCRIPTION_DISCRIMINATOR: Uint8Array;
+/** `sha256("global:top_up_subscription")[..8]`. */
+export declare const TOP_UP_SUBSCRIPTION_DISCRIMINATOR: Uint8Array;
+/** `sha256("account:Subscription")[..8]`. */
+export declare const SUBSCRIPTION_ACCOUNT_DISCRIMINATOR: Uint8Array;
+/** `sha256("account:SubLedger")[..8]`. */
+export declare const SUB_LEDGER_ACCOUNT_DISCRIMINATOR: Uint8Array;
+/** Byte offsets inside a raw `SubLedger` (fixed layout). */
+export declare const SUB_LEDGER_OFFSETS: {
+    readonly version: 8;
+    readonly payer: 9;
+    readonly mint: 41;
+    readonly total: 73;
+    readonly bump: 81;
+};
+/** Program error codes added by Pay phase 2 (`RegistryError`, 6138-6150),
+ *  plus the upgrade-5 Sentinel block at 6230-6235 (run-011 and the S-01
+ *  ledger; 6158-6229 belong to upgrade 6). Subscriptions also reuse the Pay
+ *  phase 1 codes for the fee config (6122), the `@name` binding (6126-6128)
+ *  and the mint/payee/treasury accounts (6131-6133); see `PAY_ERRORS`. */
+export declare const SUBSCRIPTION_ERRORS: {
+    readonly SubscriptionAmountZero: 6138;
+    readonly SubscriptionPeriodOutOfRange: 6139;
+    readonly SubscriptionStartOutOfRange: 6140;
+    readonly SubscriptionMintNotSupported: 6141;
+    readonly SubscriptionPayerIsPayee: 6142;
+    readonly SubscriptionDelegateInUse: 6143;
+    readonly SubscriptionNotActive: 6144;
+    readonly SubscriptionNotDue: 6145;
+    readonly SubscriptionFinished: 6146;
+    readonly SubscriptionAllowanceExhausted: 6147;
+    readonly SubscriptionTokenAccountMismatch: 6148;
+    readonly NotSubscriptionParty: 6149;
+    readonly SubscriptionStillActive: 6150;
+    /** `payee` = the payer's own `["sub_delegate", payer]` PDA. */
+    readonly SubscriptionPayeeIsDelegate: 6230;
+    /** `top_up_subscription` above `amount × charges left`. */
+    readonly SubscriptionTopUpTooLarge: 6233;
+    /** Cancel without the `SubLedger` (a ledger-counted subscription or a
+     *  give-back), or a charge of a legacy v2 subscription not yet adopted. */
+    readonly SubscriptionLedgerRequired: 6234;
+    /** The ledger total would overflow u64 (or fall below a share). */
+    readonly SubscriptionLedgerOutOfRange: 6235;
+};
+/** `Subscription.status` as stored (Borsh enum index). */
+export declare const SUBSCRIPTION_STATUS: {
+    readonly Active: 0;
+    readonly Cancelled: 1;
+};
+export type SubscriptionStatus = "active" | "cancelled";
+/** The next due time after a charge at `now >= nextDueAt`: the first slot of
+ *  the creation-anchored schedule strictly after `now` (the program's
+ *  `sub_next_due_at`). One charge per period; missed periods are forfeited. */
+export declare function subNextDueAt(nextDueAt: bigint, periodSecs: bigint, now: bigint | number): bigint;
+/** `amount × min(charges left, 12)` (unlimited = the full window),
+ *  saturating at u64::MAX: what `create_subscription` adds to the shared
+ *  approval and sets as the subscription's `allowanceLeft`. (A payer-signed
+ *  `cancel_subscription` gives back the stored `allowanceLeft`, not this.) */
+export declare function subWindowAllowance(amount: bigint, maxCharges: number, chargesMade?: number): bigint;
+/** Whether a raw mint account (owned by `owner`) may back a subscription:
+ *  any classic SPL mint; a Token-2022 mint only with extensions in
+ *  {@link SUB_ALLOWED_MINT_EXTENSIONS} (the program's
+ *  `sub_mint_extensions_allowed`). */
+export declare function isSubscriptionMintSupported(data: Uint8Array, owner: string): boolean;
+/** 16 fresh random bytes for a new subscription id (CSPRNG). */
+export declare function newSubscriptionId(): Uint8Array;
+/** A subscription: `["sub", payer, payee, id]`. */
+export declare function findSubscriptionPda(find: PdaFinder, programId: AddressLike, payer: AddressLike, payee: AddressLike, id: Uint8Array): Promise<string>;
+/** The payer's SPL delegate for every subscription: `["sub_delegate", payer]`. */
+export declare function findSubDelegatePda(find: PdaFinder, programId: AddressLike, payer: AddressLike): Promise<string>;
+/** The payer's ledger of Active subscription shares in one mint:
+ *  `["sub_ledger", payer, mint]`. */
+export declare function findSubLedgerPda(find: PdaFinder, programId: AddressLike, payer: AddressLike, mint: AddressLike): Promise<string>;
+/** Decoded `Subscription`. Addresses are base58. */
+export interface Subscription {
+    readonly version: number;
+    readonly payer: string;
+    readonly payee: string;
+    readonly id: Uint8Array;
+    readonly mint: string;
+    readonly decimals: number;
+    readonly amount: bigint;
+    readonly periodSecs: bigint;
+    readonly nextDueAt: bigint;
+    /** 0 = unlimited. */
+    readonly maxCharges: number;
+    readonly chargesMade: number;
+    readonly status: SubscriptionStatus;
+    readonly createdAt: bigint;
+    /** 0n before the first charge. */
+    readonly lastChargedAt: bigint;
+    /** The bound `Handle` account, or null. */
+    readonly handle: string | null;
+    readonly memoHash: Uint8Array;
+    readonly bump: number;
+    readonly delegateBump: number;
+    /** This subscription's own unused share of the shared approval (layout
+     *  v2). Each charge needs and spends `amount` of it; 0n for a v1 account. */
+    readonly allowanceLeft: bigint;
+}
+/**
+ * Decode a raw `Subscription` (discriminator included) in the Borsh order of
+ * state.rs: version u8 | payer | payee | id [u8;16] | mint | decimals u8 |
+ * amount u64 | period_secs i64 | next_due_at i64 | max_charges u32 |
+ * charges_made u32 | status u8 | created_at i64 | last_charged_at i64 |
+ * handle Option<Pubkey> | memo_hash [u8;32] | bump u8 | delegate_bump u8 |
+ * allowance_left u64 (version 2; a version-1 account decodes with
+ * `allowanceLeft = 0n`). Null when the bytes are not a `Subscription`.
+ */
+export declare function decodeSubscription(data: Uint8Array): Subscription | null;
+/** Borsh-encode a {@link Subscription} exactly as the program stores it (the
+ *  inverse of {@link decodeSubscription}, zero-padded to the allocation). */
+export declare function encodeSubscription(s: Subscription): Uint8Array;
+/** Decoded `SubLedger`. Addresses are base58. */
+export interface SubLedger {
+    readonly version: number;
+    readonly payer: string;
+    readonly mint: string;
+    /** Σ `allowanceLeft` of the payer's Active subscriptions in `mint`; the
+     *  SPL approval the program sets on every create / top-up. */
+    readonly total: bigint;
+    readonly bump: number;
+}
+/** Decode a raw `SubLedger` (discriminator included): version u8 | payer |
+ *  mint | total u64 | bump u8. Null when the bytes are not a `SubLedger`. */
+export declare function decodeSubLedger(data: Uint8Array): SubLedger | null;
+/** Borsh-encode a {@link SubLedger} exactly as the program stores it. */
+export declare function encodeSubLedger(l: SubLedger): Uint8Array;
+/** Read and decode a payer's `SubLedger`. Null when it does not exist yet
+ *  (no subscription in that mint so far); throws when it exists but is not
+ *  one (or, with `programId`, is not owned by it). */
+export declare function fetchSubLedger(rpc: RpcFn, address: AddressLike, opts?: {
+    readonly programId?: AddressLike;
+    readonly commitment?: string;
+}): Promise<{
+    readonly address: string;
+    readonly ledger: SubLedger;
+    readonly lamports: bigint;
+} | null>;
+/** Whether every allowed charge has been made (`maxCharges > 0`). */
+export declare function isSubscriptionFinished(s: Pick<Subscription, "maxCharges" | "chargesMade">): boolean;
+/** Whether `charge_subscription` would pass its status/schedule checks at
+ *  `nowSecs` (Active, charges left, `now >= nextDueAt`). The allowance,
+ *  balance, binding and lockdown are checked on chain. */
+export declare function isSubscriptionDue(s: Pick<Subscription, "status" | "maxCharges" | "chargesMade" | "nextDueAt">, nowSecs: bigint | number): boolean;
+/** Read and decode a Subscription. Null when it does not exist; throws when
+ *  it exists but is not one (or, with `programId`, is not owned by it). */
+export declare function fetchSubscription(rpc: RpcFn, address: AddressLike, opts?: {
+    readonly programId?: AddressLike;
+    readonly commitment?: string;
+}): Promise<{
+    readonly address: string;
+    readonly subscription: Subscription;
+    readonly lamports: bigint;
+} | null>;
+export interface CreateSubscriptionParams {
+    readonly programId: AddressLike;
+    /** Signer; opts in, pays the rent and owns `payerTokenAccount`. */
+    readonly payer: AddressLike;
+    readonly payee: AddressLike;
+    /** `["config"]`. */
+    readonly config: AddressLike;
+    /** {@link findSubscriptionPda}(payer, payee, id). */
+    readonly subscription: AddressLike;
+    /** {@link findSubDelegatePda}(payer). */
+    readonly subDelegate: AddressLike;
+    /** {@link findSubLedgerPda}(payer, mint); created by this instruction on
+     *  the payer's first subscription in the mint (payer-funded). */
+    readonly subLedger: AddressLike;
+    /** 16 bytes ({@link newSubscriptionId}). */
+    readonly id: Uint8Array;
+    /** SPL Token or Token-2022 mint. */
+    readonly mint: AddressLike;
+    /** The payer's canonical ATA for `mint` (must have no other delegate). */
+    readonly payerTokenAccount: AddressLike;
+    /** The mint's owner. */
+    readonly tokenProgram: AddressLike;
+    /** Base units per charge, > 0. */
+    readonly amount: bigint;
+    /** Seconds, {@link SUB_PERIOD_MIN_SECS}..={@link SUB_PERIOD_MAX_SECS}. */
+    readonly periodSecs: bigint;
+    /** Unix seconds of the first charge; 0n / omitted = now. */
+    readonly firstDueAt?: bigint;
+    /** Total charges; 0 / omitted = unlimited. */
+    readonly maxCharges?: number;
+    /** 32 bytes (`invoiceMemoHash` of the plan text); default zeros. */
+    readonly memoHash?: Uint8Array;
+    /** Bind to the payee's `@name` (every charge re-checks it). */
+    readonly bindHandle?: InvoiceHandleBinding;
+}
+/** The Borsh arguments of `create_subscription` (after the discriminator). */
+export declare function encodeCreateSubscriptionArgs(a: {
+    readonly id: Uint8Array;
+    readonly mint: AddressLike;
+    readonly amount: bigint;
+    readonly periodSecs: bigint;
+    readonly firstDueAt: bigint;
+    readonly maxCharges: number;
+    readonly memoHash: Uint8Array;
+    readonly bindHandle: boolean;
+}): Uint8Array;
+/**
+ * `create_subscription(id, mint, amount, period_secs, first_due_at,
+ * max_charges, memo_hash, bind_handle)`. Accounts (`CreateSubscription`):
+ * payer(s,w), payee, config, subscription(w), sub_delegate, sub_ledger(w),
+ * mint, payer_token_account(w), token_program, system_program, then the
+ * optional handle, payee_record and the binding's remaining accounts.
+ *
+ * The program records {@link subWindowAllowance} as the subscription's own
+ * `allowanceLeft`, adds it to the payer's ledger and approves `subDelegate`
+ * on `payerTokenAccount` for EXACTLY the new ledger total (the sum of every
+ * Active share in the mint), so the wallet shows that delegate approval.
+ * Fails with `SubscriptionDelegateInUse` (6143) if the ATA has another app's
+ * delegate; prepend an SPL `Revoke` if the payer agrees. Refuses `payee` =
+ * `subDelegate` (6230: funds sent there could never move).
+ */
+export declare function buildCreateSubscriptionIx(p: CreateSubscriptionParams): BuiltInstruction;
+export interface ChargeSubscriptionParams {
+    readonly programId: AddressLike;
+    /** Any signer (pays the tx fee and, once per mint, the treasury ATA rent). */
+    readonly cranker: AddressLike;
+    readonly subscription: AddressLike;
+    /** `["config"]`. */
+    readonly config: AddressLike;
+    /** `Config.treasury`. */
+    readonly treasury: AddressLike;
+    /** `["pay_config"]`, initialized or not. */
+    readonly payConfig: AddressLike;
+    /** {@link findSubDelegatePda}(Subscription.payer). */
+    readonly subDelegate: AddressLike;
+    /** {@link findSubLedgerPda}(Subscription.payer, Subscription.mint). */
+    readonly subLedger: AddressLike;
+    /** `Subscription.mint`. */
+    readonly mint: AddressLike;
+    /** The payer's canonical ATA. */
+    readonly payerTokenAccount: AddressLike;
+    /** The payee's canonical ATA (must exist). */
+    readonly payeeTokenAccount: AddressLike;
+    /** The treasury's canonical ATA (created by the program if a fee is due). */
+    readonly treasuryTokenAccount: AddressLike;
+    readonly tokenProgram: AddressLike;
+    /** Required for a handle-bound subscription (`Subscription.handle`). */
+    readonly binding?: InvoiceHandleBinding;
+}
+/**
+ * `charge_subscription()`: no arguments; the program reads every term from
+ * the Subscription. Accounts (`ChargeSubscription`): cranker(s,w),
+ * subscription(w), config, treasury, pay_config, sub_delegate,
+ * sub_ledger(w), mint, payer_token_account(w), payee_token_account(w),
+ * treasury_token_account(w), token_program, associated_token_program,
+ * system_program, then the optional handle, payee_record and the binding's
+ * remaining accounts. After an outside revoke of the payer's approval every
+ * charge fails with 6147 until the payer's next create / top-up.
+ */
+export declare function buildChargeSubscriptionIx(p: ChargeSubscriptionParams): BuiltInstruction;
+export interface CancelSubscriptionParams {
+    readonly programId: AddressLike;
+    /** The payer or the payee. */
+    readonly signer: AddressLike;
+    readonly subscription: AddressLike;
+    /** {@link findSubLedgerPda}(Subscription.payer, Subscription.mint).
+     *  Required (the cancel removes the share from it); `null` only for a
+     *  legacy version-2 subscription cancelled without `giveBack`. */
+    readonly subLedger: AddressLike | null;
+    /** Payer only: also shrink the SPL approval to `min(current, ledger total
+     *  after this cancel)` (Revoke at 0). */
+    readonly giveBack?: {
+        readonly payerTokenAccount: AddressLike;
+        readonly subDelegate: AddressLike;
+        readonly tokenProgram: AddressLike;
+    };
+}
+/** `cancel_subscription()`. Accounts (`CancelSubscription`): signer(s),
+ *  subscription(w), sub_ledger(w) (the program id as "None" when `null`),
+ *  then the optional payer_token_account(w), sub_delegate, token_program
+ *  (used only when the payer signs). */
+export declare function buildCancelSubscriptionIx(p: CancelSubscriptionParams): BuiltInstruction;
+export interface CloseSubscriptionParams {
+    readonly programId: AddressLike;
+    /** The payer or the payee. */
+    readonly signer: AddressLike;
+    readonly subscription: AddressLike;
+    /** `Subscription.payer`: receives the rent. */
+    readonly payer: AddressLike;
+}
+/** `close_subscription()`. Accounts (`CloseSubscription`): signer(s),
+ *  subscription(w), payer(w). Only once Cancelled or finished. */
+export declare function buildCloseSubscriptionIx(p: CloseSubscriptionParams): BuiltInstruction;
+export interface TopUpSubscriptionParams {
+    readonly programId: AddressLike;
+    /** Signer: `Subscription.payer` (pays the fee, and the ledger rent if a
+     *  legacy subscription has none yet; X1ID pays nothing). */
+    readonly payer: AddressLike;
+    readonly subscription: AddressLike;
+    /** `["config"]`. */
+    readonly config: AddressLike;
+    /** {@link findSubDelegatePda}(payer). */
+    readonly subDelegate: AddressLike;
+    /** {@link findSubLedgerPda}(payer, Subscription.mint). */
+    readonly subLedger: AddressLike;
+    /** The payer's canonical ATA for `Subscription.mint`. */
+    readonly payerTokenAccount: AddressLike;
+    /** The mint's token program. */
+    readonly tokenProgram: AddressLike;
+    /** Base units to ADD to `allowanceLeft` and the ledger total, > 0. For a
+     *  bounded subscription the new `allowanceLeft` may not exceed `amount ×
+     *  (maxCharges - chargesMade)` (6233). E.g. `amount × 12n` for another
+     *  12-charge window of an unlimited subscription. */
+    readonly amount: bigint;
+}
+/**
+ * `top_up_subscription(amount)`: raise ONE subscription's `allowanceLeft`
+ * and the payer's ledger total by `amount`, then approve the payer's
+ * delegate PDA for EXACTLY the new ledger total (also restoring the pool
+ * after an outside revoke). Accounts (`TopUpSubscription`): payer(s,w),
+ * subscription(w), config, sub_delegate, sub_ledger(w),
+ * payer_token_account(w), token_program, system_program. Payer only; Active
+ * and not finished; refused during lockdown and when the ATA has another
+ * app's delegate (6143).
+ */
+export declare function buildTopUpSubscriptionIx(p: TopUpSubscriptionParams): BuiltInstruction;
+export interface SubscriptionAllowanceParams {
+    /** The mint's token program (SPL Token or Token-2022). */
+    readonly tokenProgram: AddressLike;
+    /** The payer's canonical ATA. */
+    readonly payerTokenAccount: AddressLike;
+    /** {@link findSubDelegatePda}(payer). */
+    readonly subDelegate: AddressLike;
+    /** Signer: the payer (the ATA's owner). */
+    readonly payer: AddressLike;
+    /** The NEW total allowance (an SPL Approve sets, it does not add): e.g.
+     *  the payer's `SubLedger.total` ({@link fetchSubLedger}). */
+    readonly allowance: bigint;
+}
+/** A plain SPL `Approve` (instruction 4, same bytes under both token
+ *  programs) of the payer's delegate PDA: a precise re-approve, e.g. to cut
+ *  the surplus a payee-cancelled subscription left back to the ledger total.
+ *  It does NOT extend a subscription (each charge also needs the
+ *  subscription's own `allowanceLeft`); use {@link buildTopUpSubscriptionIx}
+ *  for that (it also re-approves the ledger total). */
+export declare function buildSubscriptionAllowanceIx(p: SubscriptionAllowanceParams): BuiltInstruction;
+/** Plain-language sentence for a subscription error code (6138-6150,
+ *  6230, 6233-6235), or null (see `payErrorMessage` for the shared Pay codes). */
+export declare function subscriptionErrorMessage(code: number): string | null;