@augustdigital/sdk 9.11.0 → 9.12.0

package/lib/adapters/solana/idl/vault-idl.js

@@ -5,8 +5,10 @@ exports.vaultIdl = void 0;
  * august_vault program IDL (Anchor).
  *
  * GENERATED — do not edit by hand. Source of truth is the program repo's build
- * artifact: solana-vaults `frontend/idl/august_vault.json` (synced from the
- * vendored program by `scripts/sync-idl.sh`). Regenerate from there, NOT with
+ * artifact: `target/idl/august_vault.json` from
+ * fractal-protocol/solana-upshift-vault-programs, built at the release the SDK
+ * targets (solana-vaults' `frontend/idl/august_vault.json` is a copy of the same
+ * artifact, synced from its vendored submodule). Regenerate from there, NOT with
  * `anchor idl fetch`: an Anchor IDL upload is not refreshed by a program
  * upgrade, so every IDL published for this program lineage is stale — both
  * `up12…` on mainnet (last written 2026-01-21) and the `C8B1…` devnet reference
@@ -16,6 +18,22 @@ exports.vaultIdl = void 0;
  * it: SolanaAdapter/getProgram resolve the real program id per network from
  * programIds, or from an explicit `programId` override.
  *
+ * Writability: generated from the withdrawal-queue release build (#34). Later
+ * builds (devnet runs #41) drop `mut` from accounts they only read. Do not
+ * regenerate from one of those until mainnet runs it: mainnet's build rejects
+ * those accounts arriving read-only, while every build accepts them writable.
+ * Guarded by tests/adapters/solana-idl.test.ts. Built with the doc-only fix
+ * from program PR #48 applied (`SubaccountDelegationMissing` is 6027), so it
+ * differs from #34's artifact in doc strings alone.
+ *
+ * One hand edit after generation: `operator_token_account` in `operator_deposit`
+ * and `operator_withdraw` carries no `pda`. The program derives it as the ATA of
+ * the registered subaccount's stored `address`, or of the operator when there is
+ * none, which Anchor's IDL cannot express: the generated seed names the
+ * `subaccount` account itself, so Anchor would silently resolve the wrong ATA.
+ * Without the `pda`, callers must pass the account, and a missing one throws.
+ * Pinned by tests/adapters/solana-idl.test.ts; reapply it on every regeneration.
+ *
  * Drift is guarded by tests/vaults/solana-idl-drift.test.ts: the deployed binary
  * is pinned, every discriminator declared here must appear in that binary, and
  * live VaultState accounts must decode against this file.
@@ -30,6 +48,10 @@ exports.vaultIdl = {
             discriminator: [196, 210, 90, 231, 144, 149, 140, 63],
             name: 'ProgramConfig',
         },
+        {
+            discriminator: [205, 168, 49, 209, 131, 86, 56, 195],
+            name: 'Subaccount',
+        },
         {
             discriminator: [228, 196, 82, 165, 98, 210, 235, 152],
             name: 'VaultState',
@@ -39,7 +61,7 @@ exports.vaultIdl = {
     errors: [
         {
             code: 6000,
-            msg: 'Signer must be the admin',
+            msg: 'Signer must be the operator',
             name: 'NotOperator',
         },
         {
@@ -142,6 +164,51 @@ exports.vaultIdl = {
             msg: 'Share offset must be a power of ten within the permitted range',
             name: 'InvalidShareOffset',
         },
+        {
+            code: 6021,
+            msg: "Signer is not this vault's withdrawal_queue_authority; holders request a withdrawal at the queue instead",
+            name: 'WithdrawalQueueRequired',
+        },
+        {
+            code: 6022,
+            msg: "Queue must be this vault's initialized, queue-program-owned withdrawal-queue PDA",
+            name: 'InvalidWithdrawalQueueAuthority',
+        },
+        {
+            code: 6023,
+            msg: 'The queue slot was signed by a key other than the attached queue',
+            name: 'WrongWithdrawalQueueSigner',
+        },
+        {
+            code: 6024,
+            msg: 'A withdrawal queue is already attached; detach it before attaching again',
+            name: 'WithdrawalQueueAlreadyAttached',
+        },
+        {
+            code: 6025,
+            msg: 'No withdrawal queue is attached to this vault',
+            name: 'WithdrawalQueueNotAttached',
+        },
+        {
+            code: 6026,
+            msg: 'A subaccount must differ from the operator, belong to this vault, and be passed whenever the vault has any registered',
+            name: 'InvalidSubaccount',
+        },
+        {
+            code: 6027,
+            msg: "The named address's ATA must have this vault approved as delegate, with an allowance covering the transfer",
+            name: 'SubaccountDelegationMissing',
+        },
+        {
+            code: 6028,
+            msg: 'A subaccount still holds outstanding principal and cannot be deregistered',
+            name: 'SubaccountNotEmpty',
+        },
+        {
+            code: 6029,
+            msg: 'A loss settlement may not exceed the principal that is not sitting at the destination',
+            name: 'LossExceedsShortfall',
+        },
     ],
     events: [
         {
@@ -152,6 +219,14 @@ exports.vaultIdl = {
             discriminator: [6, 132, 68, 72, 106, 106, 131, 225],
             name: 'WithdrawEvt',
         },
+        {
+            discriminator: [215, 155, 176, 78, 69, 189, 182, 34],
+            name: 'WithdrawalQueueAttached',
+        },
+        {
+            discriminator: [152, 26, 84, 125, 223, 150, 156, 122],
+            name: 'WithdrawalQueueDetached',
+        },
     ],
     instructions: [
         {
@@ -185,6 +260,41 @@ exports.vaultIdl = {
             docs: ['New accepts the Admin Nomination', '### Parameters'],
             name: 'accept_admin_nomination',
         },
+        {
+            accounts: [
+                {
+                    name: 'vault_state',
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    docs: [
+                        'This vault\'s queue PDA, `["withdrawal_queue", vault_state]` under the',
+                        'hardcoded queue program, already initialized by that program.',
+                        '',
+                    ],
+                    name: 'queue',
+                },
+            ],
+            args: [],
+            discriminator: [6, 130, 226, 67, 214, 208, 145, 212],
+            docs: [
+                "Admin attaches this vault's withdrawal queue.",
+                '',
+                "`queue` must be this vault's queue PDA under the hardcoded queue program,",
+                'already initialized there. Anything else is refused, because a stored key',
+                'nobody can sign for would freeze every exit. That PDA is a pure function',
+                'of the vault, so the instruction takes no key argument: there is exactly',
+                'one value it can store. A vault with a queue already attached is refused.',
+            ],
+            name: 'attach_withdrawal_queue',
+        },
         {
             accounts: [
                 {
@@ -435,6 +545,84 @@ exports.vaultIdl = {
             ],
             name: 'deposit_checked',
         },
+        {
+            accounts: [
+                {
+                    name: 'vault_state',
+                    writable: true,
+                },
+                {
+                    name: 'subaccount',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [83, 85, 66, 65, 67, 67, 79, 85, 78, 84],
+                            },
+                            {
+                                kind: 'account',
+                                path: 'vault_state',
+                            },
+                            {
+                                account: 'Subaccount',
+                                kind: 'account',
+                                path: 'subaccount.address',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                    writable: true,
+                },
+            ],
+            args: [],
+            discriminator: [112, 91, 26, 5, 186, 249, 34, 151],
+            docs: [
+                'Remove a registered destination, refunding its rent. Admin only, and',
+                'only once its outstanding principal is zero. Removing the last one',
+                "returns the vault to the operator's own ATA.",
+            ],
+            name: 'deregister_subaccount',
+        },
+        {
+            accounts: [
+                {
+                    name: 'vault_state',
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+                {
+                    docs: [
+                        'The attached queue, which must sign. The handler checks its key against',
+                        'the stored authority.',
+                    ],
+                    name: 'queue',
+                    signer: true,
+                },
+            ],
+            args: [],
+            discriminator: [58, 25, 112, 37, 254, 105, 157, 96],
+            docs: [
+                "Admin detaches this vault's withdrawal queue, restoring direct redemption.",
+                '',
+                'The attached queue must co-sign, which it does only from its',
+                '`release_vault`. The vault never reads queue state, so that signature is',
+                "how the queue's consent is expressed.",
+            ],
+            name: 'detach_withdrawal_queue',
+        },
         {
             accounts: [
                 {
@@ -705,44 +893,56 @@ exports.vaultIdl = {
                     writable: true,
                 },
                 {
+                    docs: [
+                        "Source: a registered subaccount's ATA, else the operator's own. Keeps the",
+                        'old name for wire compatibility.',
+                    ],
                     name: 'operator_token_account',
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                    writable: true,
+                },
+                {
+                    docs: [
+                        'Still the operator: the destination changed, not who may move funds.',
+                    ],
+                    name: 'operator',
+                    signer: true,
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    docs: [
+                        "The source's registry entry, required exactly when the vault has",
+                        'registrations. Its PDA binds it to this vault.',
+                        '',
+                        '**Last, and omittable.** Inserted mid-struct it would shift',
+                        '`deposit_mint`, breaking every pre-registry operator call on upgrade.',
+                    ],
+                    name: 'subaccount',
+                    optional: true,
                     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: 'operator',
+                                kind: 'const',
+                                value: [83, 85, 66, 65, 67, 67, 79, 85, 78, 84],
                             },
                             {
                                 kind: 'account',
-                                path: 'token_program',
+                                path: 'vault_state',
                             },
                             {
+                                account: 'Subaccount',
                                 kind: 'account',
-                                path: 'deposit_mint',
+                                path: 'subaccount.address',
                             },
                         ],
                     },
                     writable: true,
                 },
-                {
-                    name: 'deposit_mint',
-                    writable: true,
-                },
-                {
-                    name: 'operator',
-                    signer: true,
-                },
-                {
-                    name: 'token_program',
-                },
             ],
             args: [
                 {
@@ -754,7 +954,11 @@ exports.vaultIdl = {
             docs: [
                 'Operator deposit funds in the Vault',
                 '',
-                'Get tokens in',
+                "Get tokens in, from the named registered subaccount's ATA once the vault",
+                "has any, else the operator's own. From a subaccount the vault PDA — not",
+                'the operator — signs against the granted delegation; a missing or short',
+                'allowance fails `SubaccountDelegationMissing` (6027).',
+                '',
                 '### Parameters',
                 '- `amount` - The amount of tokens to get in the Vault',
             ],
@@ -802,44 +1006,53 @@ exports.vaultIdl = {
                     writable: true,
                 },
                 {
+                    docs: [
+                        "Destination: a registered subaccount's ATA, else the operator's own.",
+                        'Keeps the old name for wire compatibility.',
+                    ],
                     name: 'operator_token_account',
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                    writable: true,
+                },
+                {
+                    name: 'operator',
+                    signer: true,
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    docs: [
+                        "The destination's registry entry, required exactly when the vault has",
+                        'registrations. Its PDA binds it to this vault.',
+                        '',
+                        '**Last, and omittable.** Inserted mid-struct it would shift',
+                        '`deposit_mint`, breaking every pre-registry operator call on upgrade.',
+                    ],
+                    name: 'subaccount',
+                    optional: true,
                     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: 'operator',
+                                kind: 'const',
+                                value: [83, 85, 66, 65, 67, 67, 79, 85, 78, 84],
                             },
                             {
                                 kind: 'account',
-                                path: 'token_program',
+                                path: 'vault_state',
                             },
                             {
+                                account: 'Subaccount',
                                 kind: 'account',
-                                path: 'deposit_mint',
+                                path: 'subaccount.address',
                             },
                         ],
                     },
                     writable: true,
                 },
-                {
-                    name: 'deposit_mint',
-                    writable: true,
-                },
-                {
-                    name: 'operator',
-                    signer: true,
-                },
-                {
-                    name: 'token_program',
-                },
             ],
             args: [
                 {
@@ -851,7 +1064,12 @@ exports.vaultIdl = {
             docs: [
                 'Operator withdraw funds from the Vault',
                 '',
-                'Get tokens out',
+                "Get tokens out, to the named registered subaccount's ATA once the vault",
+                "has any, else the operator's own; the account must already exist. The",
+                "subaccount's delegation must cover its outstanding principal plus",
+                '`amount`, else `SubaccountDelegationMissing` (6027). A wrong-party ATA',
+                'fails `ConstraintTokenOwner` (2015); a non-derived token account, 2009.',
+                '',
                 '### Parameters',
                 '- `amount` - The amount of tokens to get out of the Vault',
             ],
@@ -1069,6 +1287,107 @@ exports.vaultIdl = {
             ],
             name: 'redeem_checked',
         },
+        {
+            accounts: [
+                {
+                    name: 'vault_state',
+                    writable: true,
+                },
+                {
+                    name: 'subaccount',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [83, 85, 66, 65, 67, 67, 79, 85, 78, 84],
+                            },
+                            {
+                                kind: 'account',
+                                path: 'vault_state',
+                            },
+                            {
+                                kind: 'arg',
+                                path: 'address',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    docs: [
+                        "The address's ATA, carrying the delegation. Derived from `address`, so it",
+                        'cannot disagree with the argument.',
+                    ],
+                    name: 'subaccount_ata',
+                    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: 'arg',
+                                path: 'address',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'token_program',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'deposit_mint',
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    docs: [
+                        'Admin, not the operator. Where they are the same key this buys nothing.',
+                    ],
+                    name: 'admin',
+                    signer: true,
+                    writable: true,
+                },
+                {
+                    address: '11111111111111111111111111111111',
+                    name: 'system_program',
+                },
+            ],
+            args: [
+                {
+                    name: 'address',
+                    type: 'pubkey',
+                },
+            ],
+            discriminator: [12, 219, 227, 235, 28, 220, 20, 220],
+            docs: [
+                'Register a permitted operator destination. Admin only. Once any exists,',
+                "both operator transfers must name one and the operator's own ATA is",
+                'refused.',
+                '',
+                "The address's ATA must already delegate to this vault",
+                '(`approve(subaccount_ata, vault_state, n)`) — the only on-chain proof it',
+                'can return funds. `n` also caps deployments to that destination, is spent',
+                'down by returns, and SPL clears it at zero, so it needs re-granting per',
+                'cycle; short or lapsed fails `SubaccountDelegationMissing` (6027). The',
+                "first registration adopts the vault's outstanding principal and must",
+                'cover it.',
+                '',
+                '### Parameters',
+                '- `address` - The receiving address. Must not be the operator',
+            ],
+            name: 'register_subaccount',
+        },
         {
             accounts: [
                 {
@@ -1231,6 +1550,97 @@ exports.vaultIdl = {
             ],
             name: 'set_withdrawal_fee',
         },
+        {
+            accounts: [
+                {
+                    name: 'vault_state',
+                    writable: true,
+                },
+                {
+                    name: 'subaccount',
+                    pda: {
+                        seeds: [
+                            {
+                                kind: 'const',
+                                value: [83, 85, 66, 65, 67, 67, 79, 85, 78, 84],
+                            },
+                            {
+                                kind: 'account',
+                                path: 'vault_state',
+                            },
+                            {
+                                account: 'Subaccount',
+                                kind: 'account',
+                                path: 'subaccount.address',
+                            },
+                        ],
+                    },
+                    writable: true,
+                },
+                {
+                    name: 'deposit_mint',
+                },
+                {
+                    docs: [
+                        'Read for its balance, to bound the write-down. Derived, so it cannot be',
+                        'substituted.',
+                    ],
+                    name: 'subaccount_ata',
+                    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: [
+                            {
+                                account: 'Subaccount',
+                                kind: 'account',
+                                path: 'subaccount.address',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'token_program',
+                            },
+                            {
+                                kind: 'account',
+                                path: 'deposit_mint',
+                            },
+                        ],
+                    },
+                },
+                {
+                    name: 'token_program',
+                },
+                {
+                    name: 'admin',
+                    signer: true,
+                },
+            ],
+            args: [
+                {
+                    name: 'amount',
+                    type: 'u64',
+                },
+            ],
+            discriminator: [0, 151, 152, 213, 157, 238, 7, 62],
+            docs: [
+                'Write down principal a destination will never return, after a realized',
+                'loss. Admin only; the operator reducing principal would reopen',
+                'deployment capacity.',
+                '',
+                'Bounded by `principal - ata.amount`, so funds still sitting there must be',
+                'returned rather than written off. Leaves `deployed_aum` alone. Without',
+                'this a vault that took a loss could never be closed.',
+                '',
+                '### Parameters',
+                '- `amount` - Principal to write down',
+            ],
+            name: 'settle_subaccount_loss',
+        },
         {
             accounts: [
                 {
@@ -1442,6 +1852,45 @@ exports.vaultIdl = {
                 kind: 'struct',
             },
         },
+        {
+            name: 'Subaccount',
+            type: {
+                fields: [
+                    {
+                        docs: [
+                            'In the seeds, so it cannot be used against another vault; stored for',
+                            '`getProgramAccounts` indexing.',
+                        ],
+                        name: 'vault_state',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: ['The receiving address. Its ATA is where funds go.'],
+                        name: 'address',
+                        type: 'pubkey',
+                    },
+                    {
+                        docs: [
+                            'Principal sent here and not returned. Read by the coverage rule;',
+                            'deregistration requires zero.',
+                        ],
+                        name: 'principal',
+                        type: 'u64',
+                    },
+                    {
+                        name: 'bump',
+                        type: 'u8',
+                    },
+                    {
+                        name: 'padding',
+                        type: {
+                            array: ['u64', 8],
+                        },
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
         {
             name: 'VaultState',
             type: {
@@ -1526,18 +1975,76 @@ exports.vaultIdl = {
                     },
                     {
                         docs: [
-                            'Reserved. New fields must be carved **out of** this array so `LEN` stays',
-                            '455, the size of the live mainnet vault accounts — enforced by the `const`',
-                            'assertion below the struct.',
+                            '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`.',
                             '',
-                            '**Declare them AFTER `share_offset`, never before it.** Inserting a field',
-                            'earlier shifts `share_offset` off byte 199, and every vault storing a',
-                            'non-default offset would then silently read 0 and fall back to the default.',
-                            '`share_offset_stays_at_its_byte_offset` fails if that happens.',
+                            'Shrinks in 8-byte steps only: it is an array of `u64`.',
                         ],
                         name: 'padding',
                         type: {
-                            array: ['u64', 31],
+                            array: ['u64', 25],
                         },
                     },
                 ],
@@ -1572,6 +2079,40 @@ exports.vaultIdl = {
                 kind: 'struct',
             },
         },
+        {
+            docs: ['`queue` is the key now stored in `withdrawal_queue_authority`.'],
+            name: 'WithdrawalQueueAttached',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
+        {
+            docs: ['`queue` is the key that was stored, and has just been cleared.'],
+            name: 'WithdrawalQueueDetached',
+            type: {
+                fields: [
+                    {
+                        name: 'vault',
+                        type: 'pubkey',
+                    },
+                    {
+                        name: 'queue',
+                        type: 'pubkey',
+                    },
+                ],
+                kind: 'struct',
+            },
+        },
     ],
 };
 //# sourceMappingURL=vault-idl.js.map