@augustdigital/sdk 9.11.0 → 9.12.0

package/lib/adapters/solana/idl/withdrawal-queue-idl.js

@@ -0,0 +1,1868 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawalQueueIdl = void 0;
+/**
+ * august_withdrawal_queue program IDL (Anchor).
+ *
+ * GENERATED — do not edit by hand. Source of truth is the program repo's build
+ * artifact: `target/idl/august_withdrawal_queue.json` from
+ * fractal-protocol/solana-upshift-vault-programs, built at the release the SDK
+ * targets. Regenerate from there, NOT with `anchor idl fetch`, for the same
+ * reason as `vault-idl.ts`: an uploaded IDL is not refreshed by an upgrade.
+ *
+ * Generated from release v0.3.0 (87c0f2d), which restores the request's
+ * `min_assets_out` floor. One hand edit: `finalize_withdrawal`'s `deposit_mint`
+ * stays writable, in step with `vault-idl.ts`. That build (like #41) only reads
+ * it and accepts it writable. Regenerate from the build the mainnet upgrade
+ * deploys, once mainnet runs it.
+ *
+ * `address` is a build stamp, NOT network-aware. SolanaAdapter resolves the
+ * real program id per network from `programIds.withdrawalQueue`.
+ *
+ * Drift is guarded by tests/vaults/solana-idl-drift.test.ts, which pins the
+ * deployed binary and checks that every discriminator declared here appears in
+ * it.
+ */
+exports.withdrawalQueueIdl = {
+    accounts: [
+        {
+            discriminator: [228, 196, 82, 165, 98, 210, 235, 152],
+            name: 'VaultState',
+        },
+        {
+            discriminator: [54, 56, 158, 88, 232, 203, 241, 163],
+            name: 'WithdrawalQueue',
+        },
+        {
+            discriminator: [242, 88, 147, 173, 182, 62, 229, 193],
+            name: 'WithdrawalRequest',
+        },
+    ],
+    address: 'upQhC7mgYwmHLVaatRWoGAu394piLT9th9FiQZHnPrW',
+    errors: [
+        {
+            code: 6000,
+            msg: "Signer is not the vault's admin",
+            name: 'NotVaultAdmin',
+        },
+        {
+            code: 6001,
+            msg: 'Math error',
+            name: 'MathError',
+        },
+        {
+            code: 6002,
+            msg: 'vault_state is not the vault this queue serves',
+            name: 'VaultMismatch',
+        },
+        {
+            code: 6003,
+            msg: 'Cooldown exceeds the 30-day maximum',
+            name: 'CooldownOutOfBounds',
+        },
+        {
+            code: 6004,
+            msg: 'Fulfillment window must be zero or between one and 90 days',
+            name: 'FulfillmentWindowOutOfBounds',
+        },
+        {
+            code: 6005,
+            msg: "The vault's withdrawal_queue_authority does not point at this queue",
+            name: 'QueueNotActiveOnVault',
+        },
+        {
+            code: 6006,
+            msg: 'Deposit mint carries a Token-2022 extension the queue does not support',
+            name: 'UnsupportedDepositMint',
+        },
+        {
+            code: 6007,
+            msg: 'A request must escrow at least one share',
+            name: 'ZeroShares',
+        },
+        {
+            code: 6008,
+            msg: 'Recipient must be a deposit-mint token account that is not an escrow or the vault reserve',
+            name: 'InvalidRecipient',
+        },
+        {
+            code: 6009,
+            msg: "Signer is not the request's owner",
+            name: 'NotRequestOwner',
+        },
+        {
+            code: 6010,
+            msg: "The request's fulfillment window has closed; it can only be cancelled",
+            name: 'RequestExpired',
+        },
+        {
+            code: 6011,
+            msg: 'expected_sequence does not match the request; it may have been recreated',
+            name: 'StaleRequestSequence',
+        },
+        {
+            code: 6012,
+            msg: "The request's cooldown has not elapsed",
+            name: 'CooldownNotElapsed',
+        },
+        {
+            code: 6013,
+            msg: "Signer is neither the request's owner nor its finalizer",
+            name: 'FinalizerNotAllowed',
+        },
+        {
+            code: 6014,
+            msg: "Signer is neither the vault's admin nor its operator",
+            name: 'NotVaultAdminOrOperator',
+        },
+        {
+            code: 6015,
+            msg: 'The request is already eligible; there is nothing to expedite',
+            name: 'RequestAlreadyEligible',
+        },
+        {
+            code: 6016,
+            msg: 'The share mint is freezable or carries an unsupported extension',
+            name: 'UnsupportedShareMint',
+        },
+        {
+            code: 6017,
+            msg: 'The share escrow holds nothing beyond the pending requests',
+            name: 'NothingToSweep',
+        },
+        {
+            code: 6018,
+            msg: "A sweep's destination may not be an account the queue or the vault owns",
+            name: 'InvalidSweepDestination',
+        },
+        {
+            code: 6019,
+            msg: "The payout is below the request's min_assets_out",
+            name: 'PayoutBelowFloor',
+        },
+    ],
+    events: [
+        {
+            discriminator: [183, 123, 76, 75, 208, 119, 180, 208],
+            name: 'EscrowSwept',
+        },
+        {
+            discriminator: [149, 240, 214, 55, 199, 16, 75, 127],
+            name: 'QueueConfigUpdated',
+        },
+        {
+            discriminator: [122, 178, 111, 1, 22, 158, 148, 46],
+            name: 'QueueInitialized',
+        },
+        {
+            discriminator: [71, 205, 57, 90, 244, 213, 241, 226],
+            name: 'VaultReleased',
+        },
+        {
+            discriminator: [119, 175, 207, 80, 186, 237, 229, 9],
+            name: 'WithdrawalCancelled',
+        },
+        {
+            discriminator: [131, 89, 148, 0, 6, 49, 167, 69],
+            name: 'WithdrawalExpedited',
+        },
+        {
+            discriminator: [180, 63, 101, 47, 242, 164, 179, 166],
+            name: 'WithdrawalFinalized',
+        },
+        {
+            discriminator: [75, 207, 21, 12, 160, 102, 150, 55],
+            name: 'WithdrawalRequested',
+        },
+    ],
+    instructions: [
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    relations: ['request'],
+                    writable: true,
+                },
+                {
+                    docs: ["Signs, and receives the request's rent."],
+                    name: 'owner',
+                    relations: ['request'],
+                    signer: true,
+                    writable: true,
+                },
+                {
+                    docs: [
+                        'Seeds come from its own stored fields rather than the signer, so a wrong',
+                        'signer is reported as `NotRequestOwner`.',
+                    ],
+                    name: 'request',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 114, 101,
+                                    113, 117, 101, 115, 116,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.queue',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.owner',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.request_id',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'escrow_shares',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'share_mint',
+                    relations: ['queue'],
+                },
+                {
+                    name: 'destination_share_account',
+                    writable: true,
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'expected_sequence',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [183, 104, 181, 250, 28, 128, 210, 70],
+            docs: [
+                'The owner takes a pending request back: its shares return to a share',
+                'account the owner controls and the request closes with its rent to the',
+                'owner. Allowed at any time while the request exists, in either vault',
+                'state, and while the vault is paused.',
+                '',
+                '### Parameters',
+                "- `expected_sequence` - The request's stamp, so a delayed call cannot land",
+                'on a recreated request with the same id',
+            ],
+            name: 'cancel_withdrawal',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    relations: ['request'],
+                },
+                {
+                    name: 'vault_state',
+                    relations: ['queue'],
+                },
+                {
+                    docs: ["The vault's admin or operator."],
+                    name: 'authority',
+                    signer: true,
+                },
+                {
+                    name: 'request',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 114, 101,
+                                    113, 117, 101, 115, 116,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.queue',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.owner',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.request_id',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'expected_sequence',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [179, 180, 110, 75, 218, 143, 214, 114],
+            docs: [
+                'Admin or operator makes one not-yet-eligible request finalizable now:',
+                '`eligible_at` moves to the current time; `scheduled_eligible_at` and',
+                '`expires_at` do not, so the window only ever widens. An eligible or',
+                'expired request is refused. Who may finalize is unchanged: the same',
+                'callers as before, from the earlier time.',
+                '',
+                '### Parameters',
+                "- `expected_sequence` - The request's stamp, so a delayed call cannot land",
+                'on a recreated request with the same id',
+            ],
+            name: 'expedite_request',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    relations: ['request'],
+                    writable: true,
+                },
+                {
+                    docs: ['Written by the vault inside the CPI, never by this program.'],
+                    name: 'vault_state',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'vault_deposit_ata',
+                    writable: true,
+                },
+                {
+                    name: 'fee_recipient_account',
+                    writable: true,
+                },
+                {
+                    name: 'escrow_shares',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'escrow_assets',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'share_mint',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    docs: [
+                        'Whoever chooses the moment; `WithdrawalRequest::may_finalize` decides.',
+                    ],
+                    name: 'finalizer',
+                    signer: true,
+                },
+                {
+                    docs: [
+                        'Closed on success with its rent to `owner`. Seeds come from its own',
+                        'stored fields, so no argument can point it elsewhere.',
+                    ],
+                    name: 'request',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 114, 101,
+                                    113, 117, 101, 115, 116,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.queue',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.owner',
+                            },
+                            {
+                                account: 'WithdrawalRequest',
+                                kind: 'account',
+                                path: 'request.request_id',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    docs: ['need not sign.'],
+                    name: 'owner',
+                    relations: ['request'],
+                    writable: true,
+                },
+                {
+                    docs: [
+                        "The request's stored recipient, re-validated in the handler.",
+                    ],
+                    name: 'recipient_token_account',
+                    relations: ['request'],
+                    writable: true,
+                },
+                {
+                    address: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+                    name: 'vault_program',
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'expected_sequence',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [178, 87, 206, 68, 201, 186, 164, 232],
+            docs: [
+                'Pays out a request whose cooldown has run and whose window is open: the',
+                'queue redeems the escrowed shares by CPI into the vault as its PDA,',
+                "forwards the net payout to the request's recipient, and closes the",
+                "request with its rent to the owner. Anyone the request's `finalizer`",
+                'permits may call it, the owner always, and an expedite does not change',
+                "who. The vault's `VaultPaused` and `NotEnoughLiquidity` propagate",
+                'unchanged and leave the request pending, as does a payout below the',
+                "request's `min_assets_out`.",
+                '',
+                '### Parameters',
+                "- `expected_sequence` - The request's stamp, so a delayed call cannot land",
+                'on a recreated request with the same id',
+            ],
+            name: 'finalize_withdrawal',
+        },
+        {
+            accounts: [
+                {
+                    docs: [
+                        '`Account` pins the vault program as owner, so this is a genuine vault.',
+                    ],
+                    name: 'vault_state',
+                },
+                {
+                    docs: [
+                        "The vault's admin. Authorizes creation but need not fund it.",
+                    ],
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    docs: [
+                        'Funds the three accounts below. May be the same key as `admin`.',
+                    ],
+                    name: 'payer',
+                    signer: true,
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    name: 'share_mint',
+                },
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                kind: 'account',
+                                path: 'vault_state',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    docs: [
+                        "`init_if_needed`, not `init`: an ATA's address is a pure function of",
+                        '(owner, mint, token program) and anyone may create it, so a stranger who',
+                        'created these two first would otherwise make every `initialize_queue`',
+                        'for this vault fail in the create CPI. When the account exists, Anchor',
+                        'checks its mint, authority and token program against these constraints,',
+                        'which is exactly what a fresh create would have produced. A balance',
+                        'someone already sent there is a donation; payouts are balance deltas.',
+                    ],
+                    name: 'escrow_shares',
+                    pda: {
+                        program: {
+                            kind: 'const',
+                            value: [
+                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142,
+                                13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216,
+                                219, 233, 248, 89,
+                            ],
+                        },
+                        seeds: [
+                            {
+                                kind: 'account',
+                                path: 'queue',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'token_program',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'share_mint',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'escrow_assets',
+                    pda: {
+                        program: {
+                            kind: 'const',
+                            value: [
+                                140, 151, 37, 143, 78, 36, 137, 241, 187, 61, 16, 41, 20, 142,
+                                13, 131, 11, 90, 19, 153, 218, 255, 16, 132, 4, 142, 123, 216,
+                                219, 233, 248, 89,
+                            ],
+                        },
+                        seeds: [
+                            {
+                                kind: 'account',
+                                path: 'queue',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'token_program',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'deposit_mint',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    docs: [
+                        'The program owning both mints; the vault creates its share mint under the',
+                        "deposit mint's program. The ATA program refuses a mismatch.",
+                    ],
+                    name: 'token_program',
+                },
+                {
+                    address: 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL',
+                    name: 'associated_token_program',
+                },
+                {
+                    address: '11111111111111111111111111111111',
+                    name: 'system_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'cooldown_seconds',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [174, 102, 132, 232, 90, 202, 27, 20],
+            docs: [
+                "Admin creates the vault's withdrawal queue: the queue PDA and its two",
+                'escrow token accounts. The deposit mint must be classic',
+                'SPL, or Token-2022 carrying at most the two metadata extensions.',
+                'Attaching the queue to the vault is a separate, vault-side step, and is',
+                'what makes it live.',
+                '',
+                '### Parameters',
+                '- `cooldown_seconds` - Wait between request and eligibility, at most 30 days',
+            ],
+            name: 'initialize_queue',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                },
+                {
+                    docs: ['Written by the vault inside the CPI, never by this program.'],
+                    name: 'vault_state',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                    relations: ['queue'],
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    address: 'up12bytoZBmwofqsySf2uqKQ7zpfeKiAWwfvqzJjtRt',
+                    name: 'vault_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [],
+            discriminator: [162, 80, 81, 254, 102, 228, 132, 87],
+            docs: [
+                'Admin returns the vault to instant redemption: the queue co-signs the',
+                "vault's `detach_withdrawal_queue` by CPI. It checks no liquidity: nothing",
+                'could hold assets back for the pending set once the gate is off. Pending requests',
+                "survive and finalize or cancel afterwards; the vault's gate stops new",
+                'ones. The queue account persists, so the vault can be attached again.',
+            ],
+            name: 'release_vault',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'vault_state',
+                    relations: ['queue'],
+                },
+                {
+                    docs: [
+                        "Signs the share transfer and pays the request's rent, which returns to",
+                        'them when the request closes.',
+                    ],
+                    name: 'owner',
+                    signer: true,
+                    writable: true,
+                },
+                {
+                    name: 'owner_share_account',
+                    writable: true,
+                },
+                {
+                    name: 'escrow_shares',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'share_mint',
+                    relations: ['queue'],
+                },
+                {
+                    docs: [
+                        'Deposit-mint token account paid at finalization; not an escrow or the',
+                        'vault reserve.',
+                    ],
+                    name: 'recipient_token_account',
+                },
+                {
+                    docs: [
+                        'Created here; fails if this owner already has a request with this id.',
+                    ],
+                    name: 'request',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 114, 101,
+                                    113, 117, 101, 115, 116,
+                                ],
+                            },
+                            {
+                                kind: 'account',
+                                path: 'queue',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'owner',
+                            },
+                            {
+                                kind: 'arg',
+                                path: 'request_id',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    address: '11111111111111111111111111111111',
+                    name: 'system_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'request_id',
+                    type: 'u64',
+                },
+                {
+                    name: 'shares',
+                    type: 'u64',
+                },
+                {
+                    name: 'min_assets_out',
+                    type: 'u64',
+                },
+                {
+                    name: 'finalizer',
+                    type: 'pubkey',
+                },
+            ],
+            discriminator: [251, 85, 121, 205, 56, 201, 12, 177],
+            docs: [
+                'A holder escrows `shares` and opens a request that becomes finalizable',
+                "after the queue's cooldown, paying `recipient_token_account` the shares'",
+                'value at the moment of finalization, and at least `min_assets_out`.',
+                "Requires the vault's gate to point at this queue.",
+                '',
+                '### Parameters',
+                '- `request_id` - Owner-chosen id, unique per owner while the request exists',
+                '- `shares` - Shares to escrow, nonzero',
+                '- `min_assets_out` - Floor on the net payout; zero for none',
+                '- `finalizer` - Who may finalize besides the owner; zero for anyone',
+            ],
+            name: 'request_withdrawal',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'vault_state',
+                    relations: ['queue'],
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'seconds',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [57, 78, 91, 178, 112, 152, 211, 87],
+            docs: ['Admin sets the cooldown for new requests, at most 30 days.'],
+            name: 'set_cooldown',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'vault_state',
+                    relations: ['queue'],
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [
+                {
+                    name: 'seconds',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [107, 18, 240, 153, 114, 108, 105, 120],
+            docs: [
+                'Admin sets how long after scheduled eligibility a new request may still',
+                'be finalized, in seconds: zero disables expiry, otherwise',
+                '`86_400 ..= 7_776_000` (1 to 90 days).',
+            ],
+            name: 'set_fulfillment_window',
+        },
+        {
+            accounts: [
+                {
+                    name: 'queue',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    119, 105, 116, 104, 100, 114, 97, 119, 97, 108, 95, 113, 117,
+                                    101, 117, 101,
+                                ],
+                            },
+                            {
+                                account: 'WithdrawalQueue',
+                                kind: 'account',
+                                path: 'queue.vault_state',
+                            },
+                        ],
+                    },
+                },
+                {
+                    docs: ['Read for its admin, never written.'],
+                    name: 'vault_state',
+                    relations: ['queue'],
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    name: 'escrow_shares',
+                    relations: ['queue'],
+                    writable: true,
+                },
+                {
+                    name: 'share_mint',
+                    relations: ['queue'],
+                },
+                {
+                    docs: [
+                        'Any share account neither PDA owns: nothing moves shares out of an',
+                        'account the queue owns, the escrow included, or one the vault owns, so',
+                        'shares sent to either would be stuck again.',
+                    ],
+                    name: 'destination',
+                    writable: true,
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    name: 'event_authority',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [
+                                    95, 95, 101, 118, 101, 110, 116, 95, 97, 117, 116, 104, 111,
+                                    114, 105, 116, 121,
+                                ],
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'program',
+                },
+            ],
+            args: [],
+            discriminator: [183, 242, 60, 206, 189, 47, 207, 242],
+            docs: [
+                "Admin moves whatever the share escrow holds beyond the pending requests'",
+                'shares to `destination`, so shares sent to the escrow by mistake can be',
+                'returned to whoever sent them. Nothing else moves them out, so they would',
+                'otherwise be stuck there and block `close_vault` forever. Pending',
+                'requests are never touched.',
+            ],
+            name: 'sweep_escrow_shares',
+        },
+    ],
+    metadata: {
+        description: 'Delayed redemption queue for august-vault',
+        name: 'august_withdrawal_queue',
+        spec: '0.1.0',
+        version: '0.1.0',
+    },
+    types: [
+        {
+            docs: [
+                'Shares no request owned were moved out of the escrow to `destination`.',
+            ],
+            name: 'EscrowSwept',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'shares',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'destination',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'by',
+                        type: 'pubkey',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'Emitted by every admin setter with the whole configuration after the change,',
+                'so an indexer needs no earlier state to know the current one.',
+            ],
+            name: 'QueueConfigUpdated',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'cooldown_seconds',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'fulfillment_window_seconds',
+                        type: 'u64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: ['Emitted once per vault, when its queue is created.'],
+            name: 'QueueInitialized',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'deposit_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'share_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'escrow_shares',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'escrow_assets',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'cooldown_seconds',
+                        type: 'u64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'The vault was returned to instant redemption with this much still pending.',
+            ],
+            name: 'VaultReleased',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'pending_requests',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'pending_shares',
+                        type: 'u64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            name: 'VaultState',
+            type: {
+                fields: [
+                    {
+                        name: 'operator',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'admin',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'share_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'deposit_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'fee_recipient',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'withdrawal_fee',
+                        type: 'u32',
+                    },
+                    {
+                        name: 'local_aum',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'deployed_aum',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'aum_increase_limit',
+                        type: 'u32',
+                    },
+                    {
+                        name: 'aum_decrease_limit',
+                        type: 'u32',
+                    },
+                    {
+                        name: 'pda_bump',
+                        type: {
+                            array: ['u8', 1],
+                        },
+                    },
+                    {
+                        name: 'vault_version',
+                        type: {
+                            array: ['u8', 1],
+                        },
+                    },
+                    {
+                        name: 'paused',
+                        type: 'bool',
+                    },
+                    {
+                        docs: [
+                            "This vault's virtual-share offset, in base units.",
+                            '',
+                            'Per-vault rather than global because the right value depends on what a',
+                            'base unit of the deposit mint is *worth*. The offset must dominate a',
+                            '1-unit retained sliver (so it is an absolute count), while',
+                            '`MIN_SUPPLY_MULTIPLE * offset` is the minimum first deposit — whose cost',
+                            'is that count times the base-unit price. One global constant cannot serve',
+                            'both a 6-decimal dollar stablecoin and an 8-decimal asset worth ~$100k.',
+                            '',
+                            '**Zero means "not set" and maps to [`EXTRA_SHARES`].** Vaults created',
+                            'before this field existed have zeroed padding, so they read 0 — both live',
+                            'mainnet vaults are in that state. Never read this field directly: on-chain',
+                            'use `VaultState::share_offset()`, and off-chain use',
+                            '`resolved_share_offset()` from the generated Rust client, which mirrors it.',
+                            'A raw 0 collapses the pricing to pure pro-rata, which agrees with the',
+                            'program only while the vault sits exactly at par.',
+                        ],
+                        name: 'share_offset',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'The only key permitted to redeem, or zero for "no queue".',
+                            '',
+                            'Zero is what every live vault reads — their padding is zeroed here, so the',
+                            'field arrives without a migration and redemption stays open to any holder.',
+                            "When set it holds this vault's withdrawal-queue PDA, and a direct holder",
+                            'redeem is refused with `WithdrawalQueueRequired` (6021).',
+                            '',
+                            'Two instructions write this field. `attach_withdrawal_queue` stores',
+                            "nothing but this vault's [`withdrawal_queue_pda`], and only while the field",
+                            'is zero. `detach_withdrawal_queue` clears it, and needs **both** the',
+                            "admin's signature and the stored key's. Both rules exist because a key",
+                            'nobody can sign for would freeze every exit permanently while deposits',
+                            'kept working.',
+                            '',
+                            '`close_vault` also clears it, by closing the whole account, behind its',
+                            'zero-supply and empty-reserve checks. Closing a gated vault is therefore an',
+                            'implicit detach.',
+                            '',
+                            'Read this field via [`Self::withdrawal_queue`] at every decision point.',
+                            "The only raw accesses are the two writers' own writes.",
+                        ],
+                        name: 'withdrawal_queue_authority',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Registered operator destinations. Nonzero means operator transfers must',
+                            "name one; zero means the operator's own ATA.",
+                            '',
+                            'Zero on every vault created before the registry existed, so it arrives',
+                            'without a migration. A count rather than an address because the',
+                            'destination is always passed as a PDA — this only decides *whether* one',
+                            'is required. Its safety rests on the addresses being custody the',
+                            'operator cannot sweep, and on the admin being a different party from',
+                            'the operator. One address serves one vault per deposit mint, since an',
+                            'ATA has a single delegate slot.',
+                        ],
+                        name: 'subaccount_count',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Total principal taken out and not returned, across destinations.',
+                            '',
+                            'Distinct from `deployed_aum`, which `operator_update_aum` marks with no',
+                            "tokens moving. Informational: coverage reads the destination's own",
+                            '`Subaccount::principal`, so nothing on-chain trusts this.',
+                        ],
+                        name: 'deployed_principal',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Reserved. Carve new fields **out of** this array so `LEN` stays 455, the',
+                            'size of the live mainnet accounts — enforced by the `const` assertion below.',
+                            '',
+                            '**Declare a new field immediately before `padding`.** Anything inserted',
+                            'earlier shifts the fields after it silently, and each then reads zero:',
+                            '`share_offset` (199) re-prices the vault, `withdrawal_queue_authority`',
+                            '(207) reopens a gated vault, `subaccount_count` (239) reads as no',
+                            'subaccounts and pays the operator again, `deployed_principal` (247)',
+                            'reads as nothing owed. Pinned by the per-field',
+                            '`*_stays_at_its_byte_offset` tests plus',
+                            '`every_field_stays_at_its_byte_offset`.',
+                            '',
+                            'Shrinks in 8-byte steps only: it is an array of `u64`.',
+                        ],
+                        name: 'padding',
+                        type: {
+                            array: ['u64', 25],
+                        },
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'A request was cancelled and its shares returned. `by` is the signer, always',
+                'the owner.',
+            ],
+            name: 'WithdrawalCancelled',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request_id',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'by',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'shares',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'destination',
+                        type: 'pubkey',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                "The admin or operator moved a request's eligibility to now (decision 15).",
+            ],
+            name: 'WithdrawalExpedited',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request_id',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'by',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'previous_eligible_at',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'new_eligible_at',
+                        type: 'i64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'A request was paid and closed. `assets` is what left the escrow for the',
+                "recipient: the vault's net payout, never a balance that already sat there.",
+            ],
+            name: 'WithdrawalFinalized',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request_id',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'recipient',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'finalizer',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'shares',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'assets',
+                        type: 'u64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'One queue per vault, at `["withdrawal_queue", vault_state]`. It is the escrow',
+                "authority for pending shares and the key that signs the vault's",
+                '`redeem_checked` by CPI at finalization, so its address is the value the vault',
+                'stores in `withdrawal_queue_authority`. Stores no admin key; see `crate::auth`.',
+                '',
+                'The counters and bounds move only through the methods below, so the',
+                'instructions cannot update one counter and forget its partner.',
+            ],
+            name: 'WithdrawalQueue',
+            type: {
+                fields: [
+                    {
+                        docs: [
+                            'The vault this queue serves. Every instruction binds the passed vault',
+                            'account to this key.',
+                        ],
+                        name: 'vault_state',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            "Copied from the vault at init; binds the CPI's mint accounts.",
+                        ],
+                        name: 'deposit_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            "Copied from the vault at init; binds the CPI's mint accounts.",
+                        ],
+                        name: 'share_mint',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            "ATA of this PDA for `share_mint`. Holds every pending request's shares.",
+                        ],
+                        name: 'escrow_shares',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'ATA of this PDA for `deposit_mint`. Transit only: the payout is the balance',
+                            'delta across the CPI, forwarded to the recipient in the same instruction.',
+                        ],
+                        name: 'escrow_assets',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Wait between request and eligibility, `0 ..= MAX_COOLDOWN_SECONDS`. Stamped',
+                            'per request at creation, so a change applies to new requests only.',
+                        ],
+                        name: 'cooldown_seconds',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'How long after scheduled eligibility a request may still be finalized,',
+                            '`0` (never expires) or `MIN_FULFILLMENT_WINDOW_SECONDS ..=',
+                            'MAX_FULFILLMENT_WINDOW_SECONDS`. Stamped per',
+                            'request at creation.',
+                        ],
+                        name: 'fulfillment_window_seconds',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Queue-wide counter, incremented before it is stamped on a request, so the',
+                            'first stamp is 1 and a zero stamp marks a request that was never opened.',
+                            'Not a seed: request identity is owner-scoped. It orders events and pins',
+                            'stale instructions (`expected_sequence`).',
+                        ],
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Live requests. Nothing gates on it: once the vault is released no new',
+                            'request can open, so the set closes by itself.',
+                        ],
+                        name: 'pending_requests',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Sum of `shares` over live requests: escrowed exposure, not a demand',
+                            'forecast, since a mature request is a standing exit authorization.',
+                        ],
+                        name: 'pending_shares',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Canonical bump of this PDA. The vault accepts the canonical address only,',
+                            "so this must come from Anchor's `bump` at init, never a caller.",
+                        ],
+                        name: 'bump',
+                        type: 'u8',
+                    },
+                    {
+                        docs: [
+                            'Reserved. Carve new fields **out of** this array so `LEN` stays 369. A',
+                            'field carved later reads zero on every queue that already exists, so zero',
+                            'must mean "legacy behaviour" for it, as it does for every field above.',
+                        ],
+                        name: 'padding',
+                        type: {
+                            array: ['u64', 20],
+                        },
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: [
+                'One pending withdrawal, at `["withdrawal_request", queue, owner, request_id]`.',
+                'Rent is paid by the owner and returned to them when the account closes on',
+                'finalize or cancel. One account per request, so an owner can hold many at once',
+                'and nothing is ever reallocated.',
+                '',
+                'Owner-scoped ids remove cross-user contention on a shared counter. Because an',
+                'id can be reused once its account closes, every instruction that targets an',
+                'existing request also quotes `sequence`, and a signed-but-delayed instruction',
+                'for the old request fails against the new one.',
+                '',
+                "A zero-filled request, which is what Anchor's `init` hands the handler, reads",
+                'as eligible immediately and never expiring. [`Self::schedule`] is therefore',
+                'the only way the timestamps are meant to be written.',
+            ],
+            name: 'WithdrawalRequest',
+            type: {
+                fields: [
+                    {
+                        docs: ["The queue holding this request's shares."],
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Who requested, pays rent, may cancel, and may always finalize.',
+                        ],
+                        name: 'owner',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Deposit-mint token account paid at finalization. Never an escrow or the',
+                            'vault reserve, checked at request and again at finalize.',
+                        ],
+                        name: 'recipient_token_account',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Who may finalize besides the owner. Zero means anyone. Read it through',
+                            '[`Self::may_finalize`].',
+                        ],
+                        name: 'finalizer',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: ["Shares held in the queue's escrow for this request."],
+                        name: 'shares',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Owner-chosen id, unique per owner while this account exists.',
+                        ],
+                        name: 'request_id',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Queue-wide ordering stamp at creation, from `WithdrawalQueue::open_request`.',
+                            'Quoted as `expected_sequence` by every instruction that targets this',
+                            'request.',
+                        ],
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        docs: ['Unix time the request was created.'],
+                        name: 'requested_at',
+                        type: 'i64',
+                    },
+                    {
+                        docs: [
+                            '`requested_at + cooldown` at creation. Never changes: `expires_at` is',
+                            'measured from it, so expediting cannot move a deadline.',
+                        ],
+                        name: 'scheduled_eligible_at',
+                        type: 'i64',
+                    },
+                    {
+                        docs: [
+                            'Unix time finalization may begin. Equals `scheduled_eligible_at` unless',
+                            '`expedite_request` moved it earlier; it only ever moves earlier.',
+                        ],
+                        name: 'eligible_at',
+                        type: 'i64',
+                    },
+                    {
+                        docs: [
+                            '`scheduled_eligible_at + fulfillment_window` at creation, or `0` when the',
+                            'window is disabled. Read it through [`Self::is_expired`]. An expired',
+                            'request stays pending, and counted, until cancelled.',
+                        ],
+                        name: 'expires_at',
+                        type: 'i64',
+                    },
+                    {
+                        docs: [
+                            'Bump of this PDA, for `bump = request.bump` constraints. This account',
+                            'never signs.',
+                        ],
+                        name: 'bump',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'min_assets_out',
+                        type: 'u64',
+                    },
+                    {
+                        docs: [
+                            'Reserved. Carve new fields **out of** this array so `LEN` stays 265.',
+                        ],
+                        name: 'padding',
+                        type: {
+                            array: ['u64', 8],
+                        },
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: ['A request was created and its shares escrowed.'],
+            name: 'WithdrawalRequested',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'request_id',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'owner',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'sequence',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'shares',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'recipient_token_account',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'finalizer',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'eligible_at',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'expires_at',
+                        type: 'i64',
+                    },
+                    {
+                        name: 'min_assets_out',
+                        type: 'u64',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=withdrawal-queue-idl.js.map