Type Alias VoltrVault

type VoltrVault = {
    accounts: [
        {
            discriminator: [105, 99, 219, 155, 77, 241, 7, 119];
            name: "adaptorAddReceipt";
        },
        {
            discriminator: [206, 77, 207, 208, 25, 244, 81, 172];
            name: "directWithdrawInitReceipt";
        },
        { discriminator: [45, 39, 101, 43, 115, 72, 131, 40]; name: "protocol" },
        {
            discriminator: [203, 81, 223, 141, 175, 108, 101, 114];
            name: "requestWithdrawVaultReceipt";
        },
        {
            discriminator: [51, 8, 192, 253, 115, 78, 112, 214];
            name: "strategyInitReceipt";
        },
        { discriminator: [211, 8, 232, 43, 2, 152, 117, 119]; name: "vault" },
    ];
    address: "vVoLTRjQmtFpiYoegx285Ze4gsLJ8ZxgFKVcuvmG1a8";
    errors: [
        { code: 6000; msg: "Invalid amount provided."; name: "invalidAmount" },
        { code: 6001; msg: "Invalid token mint."; name: "invalidTokenMint" },
        { code: 6002; msg: "Invalid token account."; name: "invalidTokenAccount" },
        { code: 6003; msg: "Invalid account input."; name: "invalidAccountInput" },
        { code: 6004; msg: "Math overflow."; name: "mathOverflow" },
        {
            code: 6005;
            msg: "Fee exceeds total asset value.";
            name: "feeExceedsTotalAssetValue";
        },
        { code: 6006; msg: "Max cap exceeded."; name: "maxCapExceeded" },
        { code: 6007; msg: "Vault not active."; name: "vaultNotActive" },
        {
            code: 6008;
            msg: "Manager not allowed in remaining.";
            name: "managerNotAllowed";
        },
        { code: 6009; msg: "Operation not allowed."; name: "operationNotAllowed" },
        { code: 6010; msg: "Adaptor epoch invalid."; name: "adaptorEpochInvalid" },
        {
            code: 6011;
            msg: "Fee configuration invalid.";
            name: "invalidFeeConfiguration";
        },
        {
            code: 6012;
            msg: "Withdrawal not yet available.";
            name: "withdrawalNotYetAvailable";
        },
        { code: 6013; msg: "Invalid input."; name: "invalidInput" },
        { code: 6014; msg: "Division by zero."; name: "divisionByZero" },
        {
            code: 6015;
            msg: "Instant withdraw not allowed.";
            name: "instantWithdrawNotAllowed";
        },
    ];
    events: [
        {
            discriminator: [196, 93, 173, 253, 175, 140, 121, 32];
            name: "acceptProtocolAdminEvent";
        },
        {
            discriminator: [140, 255, 29, 68, 16, 194, 251, 35];
            name: "acceptVaultAdminEvent";
        },
        {
            discriminator: [24, 181, 201, 148, 240, 183, 235, 12];
            name: "addAdaptorEvent";
        },
        {
            discriminator: [140, 76, 195, 144, 180, 178, 0, 155];
            name: "calibrateHighWaterMarkEvent";
        },
        {
            discriminator: [205, 76, 169, 255, 37, 228, 65, 130];
            name: "calibrateHighWaterMarkUnsafeEvent";
        },
        {
            discriminator: [46, 165, 24, 114, 1, 80, 205, 136];
            name: "cancelRequestWithdrawVaultEvent";
        },
        {
            discriminator: [213, 95, 219, 161, 17, 208, 93, 255];
            name: "closeStrategyEvent";
        },
        {
            discriminator: [202, 201, 118, 49, 29, 180, 116, 170];
            name: "depositStrategyEvent";
        },
        {
            discriminator: [11, 15, 7, 92, 150, 100, 165, 232];
            name: "depositVaultEvent";
        },
        {
            discriminator: [113, 202, 151, 124, 137, 255, 153, 101];
            name: "directWithdrawStrategyEvent";
        },
        {
            discriminator: [69, 48, 192, 23, 232, 22, 23, 30];
            name: "harvestFeeEvent";
        },
        {
            discriminator: [13, 81, 183, 132, 88, 43, 202, 213];
            name: "initProtocolEvent";
        },
        {
            discriminator: [169, 22, 57, 8, 15, 73, 255, 115];
            name: "initializeDirectWithdrawStrategyEvent";
        },
        {
            discriminator: [30, 233, 211, 249, 83, 188, 234, 152];
            name: "initializeStrategyEvent";
        },
        {
            discriminator: [179, 75, 50, 161, 191, 28, 245, 107];
            name: "initializeVaultEvent";
        },
        {
            discriminator: [221, 23, 12, 215, 100, 42, 97, 149];
            name: "instantWithdrawStrategyEvent";
        },
        {
            discriminator: [46, 57, 60, 20, 6, 160, 164, 247];
            name: "instantWithdrawVaultEvent";
        },
        {
            discriminator: [155, 178, 2, 29, 245, 86, 246, 153];
            name: "removeAdaptorEvent";
        },
        {
            discriminator: [59, 94, 26, 38, 47, 131, 158, 162];
            name: "requestWithdrawVaultEvent";
        },
        {
            discriminator: [14, 227, 204, 217, 62, 46, 241, 237];
            name: "updateProtocolEvent";
        },
        {
            discriminator: [61, 92, 206, 151, 162, 40, 237, 103];
            name: "updateVaultConfigEvent";
        },
        {
            discriminator: [123, 31, 27, 189, 102, 1, 121, 57];
            name: "updateVaultEvent";
        },
        {
            discriminator: [172, 1, 173, 230, 228, 61, 77, 244];
            name: "updateVaultProtocolFeeEvent";
        },
        {
            discriminator: [112, 45, 16, 172, 170, 33, 22, 212];
            name: "withdrawStrategyEvent";
        },
        {
            discriminator: [196, 123, 79, 215, 4, 214, 20, 197];
            name: "withdrawVaultEvent";
        },
    ];
    instructions: [
        {
            accounts: [
                { name: "pendingAdmin"; relations: ["protocol"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                    writable: true;
                },
            ];
            args: [];
            discriminator: [76, 35, 211, 183, 82, 72, 131, 36];
            name: "acceptProtocolAdmin";
        },
        {
            accounts: [
                { name: "pendingAdmin"; relations: ["vault"]; signer: true },
                { name: "vault"; writable: true },
            ];
            args: [];
            discriminator: [214, 137, 204, 56, 78, 214, 90, 125];
            name: "acceptVaultAdmin";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "admin"; relations: ["vault"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [];
            discriminator: [161, 145, 203, 248, 211, 202, 203, 67];
            name: "addAdaptor";
        },
        {
            accounts: [
                { name: "admin"; relations: ["vault"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "adminLpAta";
                    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: "admin" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
            ];
            args: [];
            discriminator: [178, 116, 38, 9, 23, 20, 91, 154];
            name: "calibrateHighWaterMark";
        },
        {
            accounts: [
                { name: "admin"; relations: ["vault"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
            ];
            args: [];
            discriminator: [162, 16, 96, 202, 178, 8, 187, 235];
            name: "calibrateHighWaterMarkUnsafe";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The user's LP token account from which LP tokens will be burned.",
                    ];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The request's associated token account for LP."];
                    name: "requestWithdrawLpAta";
                    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: "requestWithdrawVaultReceipt" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "requestWithdrawVaultReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    114,
                                    101,
                                    113,
                                    117,
                                    101,
                                    115,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "userTransferAuthority" },
                        ];
                    };
                    writable: true;
                },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [];
            discriminator: [231, 54, 14, 6, 223, 124, 127, 238];
            name: "cancelRequestWithdrawVault";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "manager"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault" },
                { name: "strategy" },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [];
            discriminator: [56, 247, 170, 246, 89, 221, 134, 200];
            name: "closeStrategy";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "admin"; relations: ["vault"]; signer: true },
                { name: "vault" },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    name: "vaultLpMintAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                { name: "metadataAccount"; writable: true },
                {
                    address: "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s";
                    name: "metadataProgram";
                },
                { address: "SysvarRent111111111111111111111111111111111"; name: "rent" },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "name"; type: "string" },
                { name: "symbol"; type: "string" },
                { name: "uri"; type: "string" },
            ];
            discriminator: [148, 193, 160, 116, 87, 25, 123, 103];
            name: "createLpMetadata";
        },
        {
            accounts: [
                { name: "manager"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { name: "strategy" },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    docs: ["The vault's associated token account for asset."];
                    name: "vaultAssetIdleAta";
                    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: "vaultAssetIdleAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                { name: "assetTokenProgram" },
                { name: "adaptorProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "instructionDiscriminator"; type: { option: "bytes" } },
                { name: "additionalArgs"; type: { option: "bytes" } },
            ];
            discriminator: [246, 82, 57, 226, 131, 222, 253, 249];
            name: "depositStrategy";
        },
        {
            accounts: [
                { name: "userTransferAuthority"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { name: "vaultAssetMint" },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The user's asset ATA from which they are depositing tokens.",
                    ];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The vault's associated token account for asset."];
                    name: "vaultAssetIdleAta";
                    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: "vaultAssetIdleAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    docs: ["The user's LP ATA where we will mint LP tokens."];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The PDA authority used to sign mint instructions for LP tokens.",
                    ];
                    name: "vaultLpMintAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [{ name: "amount"; type: "u64" }];
            discriminator: [126, 224, 21, 255, 228, 53, 117, 33];
            name: "depositVault";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "directWithdrawInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    100,
                                    105,
                                    114,
                                    101,
                                    99,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                },
                { name: "strategy" },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The request's LP token account from which LP tokens will be burned.",
                    ];
                    name: "requestWithdrawLpAta";
                    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: "requestWithdrawVaultReceipt" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "requestWithdrawVaultReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    114,
                                    101,
                                    113,
                                    117,
                                    101,
                                    115,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "userTransferAuthority" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [{ name: "userArgs"; type: { option: "bytes" } }];
            discriminator: [119, 33, 54, 52, 194, 8, 211, 239];
            name: "directWithdrawStrategy";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "directWithdrawInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    100,
                                    105,
                                    114,
                                    101,
                                    99,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                },
                { name: "strategy" },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The request's LP token account from which LP tokens will be burned.",
                    ];
                    name: "requestWithdrawLpAta";
                    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: "requestWithdrawVaultReceipt" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "requestWithdrawVaultReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    114,
                                    101,
                                    113,
                                    117,
                                    101,
                                    115,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "userTransferAuthority" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "userArgs"; type: { option: "bytes" } },
                { name: "tolerance"; type: "u64" },
            ];
            discriminator: [207, 51, 234, 8, 76, 164, 10, 250];
            name: "directWithdrawStrategyWithTolerance";
        },
        {
            accounts: [
                { name: "harvester"; signer: true },
                { name: "vaultManager" },
                { name: "vaultAdmin" },
                { name: "protocolAdmin" },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultLpMintAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    name: "vaultManagerLpAta";
                    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: "vaultManager" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultAdminLpAta";
                    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: "vaultAdmin" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "protocolAdminLpAta";
                    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: "protocolAdmin" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
            ];
            args: [];
            discriminator: [32, 59, 42, 128, 246, 73, 255, 47];
            name: "harvestFee";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "admin"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                    writable: true;
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [{ name: "operationalState"; type: "u16" }];
            discriminator: [3, 188, 141, 237, 225, 226, 232, 210];
            name: "initProtocol";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "admin"; relations: ["vault"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { name: "strategy" },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "directWithdrawInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    100,
                                    105,
                                    114,
                                    101,
                                    99,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "instructionDiscriminator"; type: { option: "bytes" } },
                { name: "additionalArgs"; type: { option: "bytes" } },
                { name: "allowUserArgs"; type: "bool" },
            ];
            discriminator: [248, 207, 228, 15, 13, 191, 43, 58];
            name: "initializeDirectWithdrawStrategy";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "manager"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault" },
                { name: "strategy" },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "instructionDiscriminator"; type: { option: "bytes" } },
                { name: "additionalArgs"; type: { option: "bytes" } },
            ];
            discriminator: [208, 119, 144, 145, 178, 57, 105, 252];
            name: "initializeStrategy";
        },
        {
            accounts: [
                { name: "payer"; signer: true; writable: true },
                { name: "manager" },
                { name: "admin" },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; signer: true; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                { name: "vaultAssetMint" },
                { name: "vaultAssetIdleAta"; writable: true },
                {
                    name: "vaultLpMintAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    address: "SysvarC1ock11111111111111111111111111111111";
                    name: "clock";
                },
                { address: "SysvarRent111111111111111111111111111111111"; name: "rent" },
                {
                    address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
                    name: "associatedTokenProgram";
                },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                {
                    name: "config";
                    type: { defined: { name: "vaultInitializationInput" } };
                },
                { name: "name"; type: "string" },
                { name: "description"; type: "string" },
            ];
            discriminator: [48, 191, 163, 44, 71, 129, 63, 164];
            name: "initializeVault";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "directWithdrawInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    100,
                                    105,
                                    114,
                                    101,
                                    99,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                },
                { name: "strategy" },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The user's LP token account from which LP tokens will be burned.",
                    ];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "isAmountInLp"; type: "bool" },
                { name: "isWithdrawAll"; type: "bool" },
                { name: "userArgs"; type: { option: "bytes" } },
            ];
            discriminator: [105, 57, 166, 130, 147, 221, 250, 189];
            name: "instantWithdrawStrategy";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "directWithdrawInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    100,
                                    105,
                                    114,
                                    101,
                                    99,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                },
                { name: "strategy" },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The user's LP token account from which LP tokens will be burned.",
                    ];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "isAmountInLp"; type: "bool" },
                { name: "isWithdrawAll"; type: "bool" },
                { name: "userArgs"; type: { option: "bytes" } },
                { name: "tolerance"; type: "u64" },
            ];
            discriminator: [91, 21, 70, 163, 84, 67, 106, 181];
            name: "instantWithdrawStrategyWithTolerance";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { name: "vaultAssetMint" },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The user's LP token account from which LP tokens will be burned.",
                    ];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The vault's associated token account for asset."];
                    name: "vaultAssetIdleAta";
                    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: "vaultAssetIdleAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "isAmountInLp"; type: "bool" },
                { name: "isWithdrawAll"; type: "bool" },
            ];
            discriminator: [221, 56, 115, 168, 128, 220, 235, 245];
            name: "instantWithdrawVault";
        },
        {
            accounts: [
                { name: "admin"; relations: ["vault"]; signer: true; writable: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                    writable: true;
                },
                { name: "adaptorProgram" },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [];
            discriminator: [161, 199, 99, 22, 25, 193, 61, 193];
            name: "removeAdaptor";
        },
        {
            accounts: [
                {
                    docs: ["The payer of the request"];
                    name: "payer";
                    signer: true;
                    writable: true;
                },
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault" },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    docs: [
                        "The user's LP token account from which LP tokens will be burned.",
                    ];
                    name: "userLpAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The request's associated token account for LP."];
                    name: "requestWithdrawLpAta";
                    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: "requestWithdrawVaultReceipt" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "requestWithdrawVaultReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    114,
                                    101,
                                    113,
                                    117,
                                    101,
                                    115,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "userTransferAuthority" },
                        ];
                    };
                    writable: true;
                },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "isAmountInLp"; type: "bool" },
                { name: "isWithdrawAll"; type: "bool" },
            ];
            discriminator: [248, 225, 47, 22, 116, 144, 23, 143];
            name: "requestWithdrawVault";
        },
        {
            accounts: [
                { name: "admin"; relations: ["protocol"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                    writable: true;
                },
            ];
            args: [
                { name: "field"; type: { defined: { name: "protocolConfigField" } } },
                { name: "data"; type: "bytes" },
            ];
            discriminator: [206, 25, 218, 114, 109, 41, 74, 173];
            name: "updateProtocol";
        },
        {
            accounts: [
                { name: "admin"; relations: ["vault"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { address: "SysvarRent111111111111111111111111111111111"; name: "rent" },
            ];
            args: [
                { name: "field"; type: { defined: { name: "vaultConfigField" } } },
                { name: "data"; type: "bytes" },
            ];
            discriminator: [122, 3, 21, 222, 158, 255, 238, 157];
            name: "updateVaultConfig";
        },
        {
            accounts: [
                { name: "admin"; relations: ["protocol"]; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
            ];
            args: [
                { name: "field"; type: { defined: { name: "protocolFeeField" } } },
                { name: "feeBps"; type: "u16" },
            ];
            discriminator: [62, 83, 22, 192, 137, 86, 74, 18];
            name: "updateVaultProtocolFee";
        },
        {
            accounts: [
                { name: "manager"; signer: true },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                {
                    name: "adaptorAddReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    97,
                                    100,
                                    97,
                                    112,
                                    116,
                                    111,
                                    114,
                                    95,
                                    97,
                                    100,
                                    100,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "adaptorProgram" },
                        ];
                    };
                },
                {
                    name: "strategyInitReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    105,
                                    110,
                                    105,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { name: "strategy" },
                { name: "adaptorProgram" },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    115,
                                    116,
                                    114,
                                    97,
                                    116,
                                    101,
                                    103,
                                    121,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "strategy" },
                        ];
                    };
                    writable: true;
                },
                { name: "vaultAssetMint"; writable: true },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                },
                {
                    docs: ["The vault's associated token account for asset."];
                    name: "vaultAssetIdleAta";
                    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: "vaultAssetIdleAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultStrategyAssetAta";
                    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: "vaultStrategyAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                { name: "assetTokenProgram" },
            ];
            args: [
                { name: "amount"; type: "u64" },
                { name: "instructionDiscriminator"; type: { option: "bytes" } },
                { name: "additionalArgs"; type: { option: "bytes" } },
            ];
            discriminator: [31, 45, 162, 5, 193, 217, 134, 188];
            name: "withdrawStrategy";
        },
        {
            accounts: [
                {
                    docs: [
                        "The authority that owns the LP tokens and wants to redeem them",
                    ];
                    name: "userTransferAuthority";
                    signer: true;
                    writable: true;
                },
                {
                    name: "protocol";
                    pda: {
                        seeds: [
                            { kind: "const"; value: [112, 114, 111, 116, 111, 99, 111, 108] },
                        ];
                    };
                },
                { name: "vault"; writable: true },
                { name: "vaultAssetMint" },
                {
                    name: "vaultLpMint";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    108,
                                    112,
                                    95,
                                    109,
                                    105,
                                    110,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: [
                        "The request's LP token account from which LP tokens will be burned.",
                    ];
                    name: "requestWithdrawLpAta";
                    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: "requestWithdrawVaultReceipt" },
                            { kind: "account"; path: "lpTokenProgram" },
                            { kind: "account"; path: "vaultLpMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The vault's associated token account for asset."];
                    name: "vaultAssetIdleAta";
                    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: "vaultAssetIdleAuth" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "vaultAssetIdleAuth";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    97,
                                    115,
                                    115,
                                    101,
                                    116,
                                    95,
                                    105,
                                    100,
                                    108,
                                    101,
                                    95,
                                    97,
                                    117,
                                    116,
                                    104,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                        ];
                    };
                    writable: true;
                },
                {
                    docs: ["The user's asset ATA to which asset tokens will be sent."];
                    name: "userAssetAta";
                    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: "userTransferAuthority" },
                            { kind: "account"; path: "assetTokenProgram" },
                            { kind: "account"; path: "vaultAssetMint" },
                        ];
                    };
                    writable: true;
                },
                {
                    name: "requestWithdrawVaultReceipt";
                    pda: {
                        seeds: [
                            {
                                kind: "const";
                                value: [
                                    114,
                                    101,
                                    113,
                                    117,
                                    101,
                                    115,
                                    116,
                                    95,
                                    119,
                                    105,
                                    116,
                                    104,
                                    100,
                                    114,
                                    97,
                                    119,
                                    95,
                                    118,
                                    97,
                                    117,
                                    108,
                                    116,
                                    95,
                                    114,
                                    101,
                                    99,
                                    101,
                                    105,
                                    112,
                                    116,
                                ];
                            },
                            { kind: "account"; path: "vault" },
                            { kind: "account"; path: "userTransferAuthority" },
                        ];
                    };
                    writable: true;
                },
                { name: "assetTokenProgram" },
                {
                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
                    name: "lpTokenProgram";
                },
                { address: "11111111111111111111111111111111"; name: "systemProgram" },
            ];
            args: [];
            discriminator: [135, 7, 237, 120, 149, 94, 95, 7];
            name: "withdrawVault";
        },
    ];
    metadata: {
        description: "Created with Anchor";
        name: "voltrVault";
        spec: "0.1.0";
        version: "0.2.0";
    };
    types: [
        {
            name: "acceptProtocolAdminEvent";
            type: {
                fields: [
                    { name: "protocol"; type: "pubkey" },
                    { name: "adminBefore"; type: "pubkey" },
                    { name: "adminAfter"; type: "pubkey" },
                    { name: "acceptedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "acceptVaultAdminEvent";
            type: {
                fields: [
                    { name: "vault"; type: "pubkey" },
                    { name: "adminBefore"; type: "pubkey" },
                    { name: "adminAfter"; type: "pubkey" },
                    { name: "acceptedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "adaptorAddReceipt";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The vault associated with this strategy."];
                        name: "vault";
                        type: "pubkey";
                    },
                    {
                        docs: ["The adapter program address."];
                        name: "adaptorProgram";
                        type: "pubkey";
                    },
                    { docs: ["A version number (1 byte)."]; name: "version"; type: "u8" },
                    {
                        docs: ["The bump for the adaptor add receipt."];
                        name: "bump";
                        type: "u8";
                    },
                    {
                        docs: [
                            "7 bytes of padding to align future 8-byte fields on 8-byte boundaries.",
                        ];
                        name: "padding0";
                        type: { array: ["u8", 7] };
                    },
                    {
                        docs: ["The epoch at which the strategy was last updated."];
                        name: "lastUpdatedEpoch";
                        type: "u64";
                    },
                    {
                        docs: ["Reserved space for future fields"];
                        name: "reserved";
                        type: { array: ["u8", 56] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "addAdaptorEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "adaptorAddReceipt"; type: "pubkey" },
                    { name: "adaptorLastUpdatedTs"; type: "u64" },
                    { name: "addedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "calibrateHighWaterMarkEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultAssetTotalValue"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "amountLpBurned"; type: "u64" },
                    { name: "calibratedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "calibrateHighWaterMarkUnsafeEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultAssetTotalValue"; type: "u64" },
                    { name: "vaultLpSupplyInclFees"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "calibratedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "cancelRequestWithdrawVaultEvent";
            type: {
                fields: [
                    { name: "vault"; type: "pubkey" },
                    { name: "user"; type: "pubkey" },
                    { name: "requestWithdrawVaultReceipt"; type: "pubkey" },
                    { name: "amountLpRefunded"; type: "u64" },
                    { name: "amountLpBurned"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "cancelledTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "closeStrategyEvent";
            type: {
                fields: [
                    { name: "manager"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "closedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "depositStrategyEvent";
            type: {
                fields: [
                    { name: "manager"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAmountAssetDeposited"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "vaultAssetIdleAtaAmountBefore"; type: "u64" },
                    { name: "vaultAssetIdleAtaAmountAfter"; type: "u64" },
                    { name: "strategyPositionValueBefore"; type: "u64" },
                    { name: "strategyPositionValueAfter"; type: "u64" },
                    { name: "depositedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "depositVaultEvent";
            type: {
                fields: [
                    { name: "user"; type: "pubkey" },
                    { name: "userAmountAssetDeposited"; type: "u64" },
                    { name: "userAmountLpMinted"; type: "u64" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesBefore"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesAfter"; type: "u64" },
                    { name: "vaultLpDeadWeightBefore"; type: "u64" },
                    { name: "vaultLpDeadWeightAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "depositedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "directWithdrawInitReceipt";
            type: {
                fields: [
                    {
                        docs: ["The vault associated with this strategy."];
                        name: "vault";
                        type: "pubkey";
                    },
                    { docs: ["The strategy address."]; name: "strategy"; type: "pubkey" },
                    {
                        docs: ["The position value."];
                        name: "adaptorProgram";
                        type: "pubkey";
                    },
                    {
                        docs: ["The instruction discriminator."];
                        name: "instructionDiscriminator";
                        type: "bytes";
                    },
                    {
                        docs: ["The additional arguments."];
                        name: "additionalArgs";
                        type: { option: "bytes" };
                    },
                    {
                        docs: ["Whether the user args are allowed."];
                        name: "allowUserArgs";
                        type: "bool";
                    },
                    { docs: ["A version number (1 byte)."]; name: "version"; type: "u8" },
                    {
                        docs: ["The bump for the strategy init receipt."];
                        name: "bump";
                        type: "u8";
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "directWithdrawStrategyEvent";
            type: {
                fields: [
                    { name: "user"; type: "pubkey" },
                    { name: "userAmountAssetWithdrawn"; type: "u64" },
                    { name: "userAmountLpBurned"; type: "u64" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "directWithdrawInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueUnlockedBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesBefore"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesAfter"; type: "u64" },
                    { name: "vaultLpDeadWeightBefore"; type: "u64" },
                    { name: "vaultLpDeadWeightAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "strategyPositionValueBefore"; type: "u64" },
                    { name: "strategyPositionValueAfter"; type: "u64" },
                    { name: "withdrawnTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "feeConfiguration";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["Manager performance fee in basis points (BPS)."];
                        name: "managerPerformanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Admin performance fee in basis points (BPS)."];
                        name: "adminPerformanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Manager management fee in basis points (BPS)."];
                        name: "managerManagementFee";
                        type: "u16";
                    },
                    {
                        docs: ["Admin management fee in basis points (BPS)."];
                        name: "adminManagementFee";
                        type: "u16";
                    },
                    {
                        docs: ["The redemption fee in basis points (BPS)."];
                        name: "redemptionFee";
                        type: "u16";
                    },
                    {
                        docs: ["The issuance fee in basis points (BPS)."];
                        name: "issuanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Protocol performance fee in basis points (BPS)."];
                        name: "protocolPerformanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Protocol management fee in basis points (BPS)."];
                        name: "protocolManagementFee";
                        type: "u16";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 32] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "feeState";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The accumulated manager fees in the vault."];
                        name: "accumulatedLpManagerFees";
                        type: "u64";
                    },
                    {
                        docs: ["The accumulated admin fees in the vault."];
                        name: "accumulatedLpAdminFees";
                        type: "u64";
                    },
                    {
                        docs: ["The accumulated protocol fees in the vault."];
                        name: "accumulatedLpProtocolFees";
                        type: "u64";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 16] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "feeUpdate";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: [
                            "The timestamp when the performance fees were last updated.",
                        ];
                        name: "lastPerformanceFeeUpdateTs";
                        type: "u64";
                    },
                    {
                        docs: ["The timestamp when the management fees were last updated."];
                        name: "lastManagementFeeUpdateTs";
                        type: "u64";
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "harvestFeeEvent";
            type: {
                fields: [
                    { name: "harvester"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "protocol"; type: "pubkey" },
                    { name: "admin"; type: "pubkey" },
                    { name: "manager"; type: "pubkey" },
                    { name: "amountLpAdminFees"; type: "u64" },
                    { name: "amountLpManagerFees"; type: "u64" },
                    { name: "amountLpProtocolFees"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "highWaterMark";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The highest recorded total asset value per share"];
                        name: "highestAssetPerLpDecimalBits";
                        type: "u128";
                    },
                    {
                        docs: ["The timestamp when the high water mark was last updated"];
                        name: "lastUpdatedTs";
                        type: "u64";
                    },
                    {
                        docs: ["Reserved for future use"];
                        name: "reserved";
                        type: { array: ["u8", 8] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "initProtocolEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "operationalState"; type: "u16" },
                    { name: "initializedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "initializeDirectWithdrawStrategyEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "instructionDiscriminator"; type: "bytes" },
                    { name: "additionalArgs"; type: "bytes" },
                    { name: "allowUserArgs"; type: "bool" },
                    { name: "initializedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "initializeStrategyEvent";
            type: {
                fields: [
                    { name: "manager"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultStrategyAuth"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "initializedTs"; type: "u64" },
                    { name: "isInitialized"; type: "bool" },
                ];
                kind: "struct";
            };
        },
        {
            name: "initializeVaultEvent";
            type: {
                fields: [
                    { name: "payer"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultName"; type: "string" },
                    { name: "vaultDescription"; type: "string" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetIdleAta"; type: "pubkey" },
                    { name: "vaultLpMint"; type: "pubkey" },
                    { name: "vaultManager"; type: "pubkey" },
                    { name: "vaultAdmin"; type: "pubkey" },
                    { name: "vaultConfigMaxCap"; type: "u64" },
                    { name: "vaultConfigStartAtTs"; type: "u64" },
                    { name: "vaultConfigLockedProfitDegradationDuration"; type: "u64" },
                    { name: "vaultConfigWithdrawalWaitingPeriod"; type: "u64" },
                    { name: "vaultConfigManagerPerformanceFee"; type: "u16" },
                    { name: "vaultConfigAdminPerformanceFee"; type: "u16" },
                    { name: "vaultConfigManagerManagementFee"; type: "u16" },
                    { name: "vaultConfigAdminManagementFee"; type: "u16" },
                    { name: "vaultConfigRedemptionFee"; type: "u16" },
                    { name: "vaultConfigIssuanceFee"; type: "u16" },
                    { name: "initializedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "instantWithdrawStrategyEvent";
            type: {
                fields: [
                    { name: "user"; type: "pubkey" },
                    { name: "amount"; type: "u64" },
                    { name: "isAmountInLp"; type: "bool" },
                    { name: "isWithdrawAll"; type: "bool" },
                    { name: "userAmountAssetWithdrawn"; type: "u64" },
                    { name: "userAmountLpBurned"; type: "u64" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "directWithdrawInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueUnlockedBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesBefore"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesAfter"; type: "u64" },
                    { name: "vaultLpDeadWeightBefore"; type: "u64" },
                    { name: "vaultLpDeadWeightAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "strategyPositionValueBefore"; type: "u64" },
                    { name: "strategyPositionValueAfter"; type: "u64" },
                    { name: "withdrawnTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "instantWithdrawVaultEvent";
            type: {
                fields: [
                    { name: "user"; type: "pubkey" },
                    { name: "amount"; type: "u64" },
                    { name: "isAmountInLp"; type: "bool" },
                    { name: "isWithdrawAll"; type: "bool" },
                    { name: "userAmountAssetWithdrawn"; type: "u64" },
                    { name: "userAmountLpBurned"; type: "u64" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueUnlockedBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesBefore"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesAfter"; type: "u64" },
                    { name: "vaultLpDeadWeightBefore"; type: "u64" },
                    { name: "vaultLpDeadWeightAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "withdrawnTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "lockedProfitState";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    { name: "lastUpdatedLockedProfit"; type: "u64" },
                    { name: "lastReport"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "protocol";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The admin of the protocol."];
                        name: "admin";
                        type: "pubkey";
                    },
                    {
                        docs: ["The operational state of the protocol."];
                        name: "operationalState";
                        type: "u16";
                    },
                    {
                        docs: ["previously used for fee, now unused"];
                        name: "padding1";
                        type: { array: ["u8", 2] };
                    },
                    { docs: ["The bump for the protocol."]; name: "bump"; type: "u8" },
                    {
                        docs: [
                            "1 byte of padding to align future 8-byte fields on 8-byte boundaries.",
                        ];
                        name: "padding0";
                        type: { array: ["u8", 1] };
                    },
                    {
                        docs: ["The pending admin for admin transfer."];
                        name: "pendingAdmin";
                        type: "pubkey";
                    },
                    {
                        docs: ["Reserved space for future fields"];
                        name: "reserved";
                        type: { array: ["u8", 32] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "protocolConfigField";
            type: {
                kind: "enum";
                variants: [{ name: "operationalState" }, { name: "pendingAdmin" }];
            };
        },
        {
            name: "protocolFeeField";
            type: {
                kind: "enum";
                variants: [
                    { name: "protocolPerformanceFee" },
                    { name: "protocolManagementFee" },
                ];
            };
        },
        {
            name: "removeAdaptorEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "adaptorAddReceipt"; type: "pubkey" },
                    { name: "removedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "requestWithdrawVaultEvent";
            type: {
                fields: [
                    { name: "vault"; type: "pubkey" },
                    { name: "user"; type: "pubkey" },
                    { name: "requestedAmount"; type: "u64" },
                    { name: "isAmountInLp"; type: "bool" },
                    { name: "isWithdrawAll"; type: "bool" },
                    { name: "requestWithdrawVaultReceipt"; type: "pubkey" },
                    { name: "amountLpEscrowed"; type: "u64" },
                    { name: "amountAssetToWithdrawDecimalBits"; type: "u128" },
                    { name: "withdrawableFromTs"; type: "u64" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueUnlocked"; type: "u64" },
                    { name: "vaultAssetTotalValue"; type: "u64" },
                    { name: "vaultLpSupplyInclFees"; type: "u64" },
                    { name: "requestedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "requestWithdrawVaultReceipt";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    { name: "vault"; type: "pubkey" },
                    { name: "user"; type: "pubkey" },
                    { name: "amountLpEscrowed"; type: "u64" },
                    { name: "amountAssetToWithdrawDecimalBits"; type: "u128" },
                    { name: "withdrawableFromTs"; type: "u64" },
                    { name: "bump"; type: "u8" },
                    { name: "version"; type: "u8" },
                ];
                kind: "struct";
            };
        },
        {
            name: "strategyInitReceipt";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The vault associated with this strategy."];
                        name: "vault";
                        type: "pubkey";
                    },
                    { docs: ["The strategy address."]; name: "strategy"; type: "pubkey" },
                    {
                        docs: ["The adaptor program address."];
                        name: "adaptorProgram";
                        type: "pubkey";
                    },
                    { docs: ["The position value."]; name: "positionValue"; type: "u64" },
                    {
                        docs: ["The last updated timestamp."];
                        name: "lastUpdatedTs";
                        type: "u64";
                    },
                    { docs: ["A version number (1 byte)."]; name: "version"; type: "u8" },
                    {
                        docs: ["The bump for the strategy init receipt."];
                        name: "bump";
                        type: "u8";
                    },
                    {
                        docs: ["The bump for the vault strategy auth."];
                        name: "vaultStrategyAuthBump";
                        type: "u8";
                    },
                    {
                        docs: [
                            "6 bytes of padding to align future 8-byte fields on 8-byte boundaries.",
                        ];
                        name: "padding0";
                        type: { array: ["u8", 5] };
                    },
                    {
                        docs: ["Reserved space for future fields"];
                        name: "reserved";
                        type: { array: ["u8", 64] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "updateProtocolEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "protocol"; type: "pubkey" },
                    { name: "field"; type: "string" },
                    { name: "oldValue"; type: "string" },
                    { name: "newValue"; type: "string" },
                    { name: "updatedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "updateVaultConfigEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "field"; type: "string" },
                    { name: "oldValue"; type: "string" },
                    { name: "newValue"; type: "string" },
                    { name: "updatedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "updateVaultEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultConfigMaxCapBefore"; type: "u64" },
                    { name: "vaultConfigMaxCapAfter"; type: "u64" },
                    { name: "vaultConfigStartAtTsBefore"; type: "u64" },
                    { name: "vaultConfigStartAtTsAfter"; type: "u64" },
                    {
                        name: "vaultConfigLockedProfitDegradationDurationBefore";
                        type: "u64";
                    },
                    {
                        name: "vaultConfigLockedProfitDegradationDurationAfter";
                        type: "u64";
                    },
                    { name: "vaultConfigWithdrawalWaitingPeriodBefore"; type: "u64" },
                    { name: "vaultConfigWithdrawalWaitingPeriodAfter"; type: "u64" },
                    { name: "vaultConfigManagerPerformanceFeeBefore"; type: "u16" },
                    { name: "vaultConfigManagerPerformanceFeeAfter"; type: "u16" },
                    { name: "vaultConfigAdminPerformanceFeeBefore"; type: "u16" },
                    { name: "vaultConfigAdminPerformanceFeeAfter"; type: "u16" },
                    { name: "vaultConfigManagerManagementFeeBefore"; type: "u16" },
                    { name: "vaultConfigManagerManagementFeeAfter"; type: "u16" },
                    { name: "vaultConfigAdminManagementFeeBefore"; type: "u16" },
                    { name: "vaultConfigAdminManagementFeeAfter"; type: "u16" },
                    { name: "vaultConfigRedemptionFeeBefore"; type: "u16" },
                    { name: "vaultConfigRedemptionFeeAfter"; type: "u16" },
                    { name: "vaultConfigIssuanceFeeBefore"; type: "u16" },
                    { name: "vaultConfigIssuanceFeeAfter"; type: "u16" },
                    { name: "updatedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "updateVaultProtocolFeeEvent";
            type: {
                fields: [
                    { name: "admin"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "field"; type: "string" },
                    { name: "oldValue"; type: "u16" },
                    { name: "newValue"; type: "u16" },
                    { name: "updatedTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "vault";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The vault's name."];
                        name: "name";
                        type: { array: ["u8", 32] };
                    },
                    {
                        docs: ["A description or summary for this vault."];
                        name: "description";
                        type: { array: ["u8", 64] };
                    },
                    {
                        docs: [
                            "The vault’s main asset configuration (inline nested struct).",
                        ];
                        name: "asset";
                        type: { defined: { name: "vaultAsset" } };
                    },
                    {
                        docs: [
                            "The vault’s LP (share) configuration (inline nested struct).",
                        ];
                        name: "lp";
                        type: { defined: { name: "vaultLp" } };
                    },
                    {
                        docs: ["The pending admin for admin transfer."];
                        name: "pendingAdmin";
                        type: "pubkey";
                    },
                    {
                        docs: ["The manager of this vault (has certain permissions)."];
                        name: "manager";
                        type: "pubkey";
                    },
                    {
                        docs: [
                            "The admin of this vault (broader or fallback permissions).",
                        ];
                        name: "admin";
                        type: "pubkey";
                    },
                    {
                        docs: [
                            "The vault fee, cap, and locked profit degradation duration configuration (inline nested struct).",
                        ];
                        name: "vaultConfiguration";
                        type: { defined: { name: "vaultConfiguration" } };
                    },
                    {
                        docs: [
                            "The vault fee and cap configuration (inline nested struct).",
                        ];
                        name: "feeConfiguration";
                        type: { defined: { name: "feeConfiguration" } };
                    },
                    {
                        docs: ["The fee update state of the vault."];
                        name: "feeUpdate";
                        type: { defined: { name: "feeUpdate" } };
                    },
                    {
                        docs: ["The fee state of the vault."];
                        name: "feeState";
                        type: { defined: { name: "feeState" } };
                    },
                    {
                        docs: ["The accumulated dead weight of the vault."];
                        name: "deadWeight";
                        type: "u64";
                    },
                    { name: "highWaterMark"; type: { defined: { name: "highWaterMark" } } },
                    {
                        docs: [
                            "The last time (Unix timestamp) this vault data was updated.",
                        ];
                        name: "lastUpdatedTs";
                        type: "u64";
                    },
                    { docs: ["The version of the vault."]; name: "version"; type: "u8" },
                    {
                        docs: [
                            "padding to align future 8-byte fields on 8-byte boundaries.",
                        ];
                        name: "padding0";
                        type: { array: ["u8", 7] };
                    },
                    {
                        docs: ["The locked profit state of the vault."];
                        name: "lockedProfitState";
                        type: { defined: { name: "lockedProfitState" } };
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 240] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "vaultAsset";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The mint for the vault’s main asset."];
                        name: "mint";
                        type: "pubkey";
                    },
                    {
                        docs: ["The “idle” token account holding un-invested assets."];
                        name: "idleAta";
                        type: "pubkey";
                    },
                    {
                        docs: ["The total amount of this asset currently in the vault."];
                        name: "totalValue";
                        type: "u64";
                    },
                    {
                        docs: ["The bump for the vault asset mint."];
                        name: "idleAtaAuthBump";
                        type: "u8";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 95] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "vaultConfigField";
            type: {
                kind: "enum";
                variants: [
                    { name: "maxCap" },
                    { name: "startAtTs" },
                    { name: "lockedProfitDegradationDuration" },
                    { name: "withdrawalWaitingPeriod" },
                    { name: "managerPerformanceFee" },
                    { name: "adminPerformanceFee" },
                    { name: "managerManagementFee" },
                    { name: "adminManagementFee" },
                    { name: "redemptionFee" },
                    { name: "issuanceFee" },
                    { name: "manager" },
                    { name: "pendingAdmin" },
                    { name: "disabledOperations" },
                ];
            };
        },
        {
            name: "vaultConfiguration";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The maximum total amount allowed in the vault."];
                        name: "maxCap";
                        type: "u64";
                    },
                    { docs: ["active from timestamp"]; name: "startAtTs"; type: "u64" },
                    {
                        docs: ["The locked profit degradation duration."];
                        name: "lockedProfitDegradationDuration";
                        type: "u64";
                    },
                    {
                        docs: ["The waiting period for a withdrawal. prec: seconds"];
                        name: "withdrawalWaitingPeriod";
                        type: "u64";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "disabledOperations";
                        type: "u16";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 46] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "vaultInitializationInput";
            type: {
                fields: [
                    {
                        docs: ["The maximum total amount allowed in the vault."];
                        name: "maxCap";
                        type: "u64";
                    },
                    { docs: ["active from timestamp"]; name: "startAtTs"; type: "u64" },
                    {
                        docs: ["Manager performance fee in basis points (BPS)."];
                        name: "managerPerformanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Admin performance fee in basis points (BPS)."];
                        name: "adminPerformanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["Manager management fee in basis points (BPS)."];
                        name: "managerManagementFee";
                        type: "u16";
                    },
                    {
                        docs: ["Admin management fee in basis points (BPS)."];
                        name: "adminManagementFee";
                        type: "u16";
                    },
                    {
                        docs: ["The locked profit degradation duration."];
                        name: "lockedProfitDegradationDuration";
                        type: "u64";
                    },
                    {
                        docs: ["The redemption fee in basis points (BPS)."];
                        name: "redemptionFee";
                        type: "u16";
                    },
                    {
                        docs: ["The issuance fee in basis points (BPS)."];
                        name: "issuanceFee";
                        type: "u16";
                    },
                    {
                        docs: ["The waiting period for a withdrawal."];
                        name: "withdrawalWaitingPeriod";
                        type: "u64";
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "vaultLp";
            repr: { kind: "c" };
            serialization: "bytemuckunsafe";
            type: {
                fields: [
                    {
                        docs: ["The LP mint (e.g., representing shares in this vault)."];
                        name: "mint";
                        type: "pubkey";
                    },
                    {
                        docs: ["The bump for the vault LP mint."];
                        name: "mintBump";
                        type: "u8";
                    },
                    {
                        docs: ["The bump for the vault LP mint authority."];
                        name: "mintAuthBump";
                        type: "u8";
                    },
                    {
                        docs: ["Reserved bytes for future use."];
                        name: "reserved";
                        type: { array: ["u8", 30] };
                    },
                ];
                kind: "struct";
            };
        },
        {
            name: "withdrawStrategyEvent";
            type: {
                fields: [
                    { name: "manager"; type: "pubkey" },
                    { name: "vault"; type: "pubkey" },
                    { name: "strategy"; type: "pubkey" },
                    { name: "strategyInitReceipt"; type: "pubkey" },
                    { name: "adaptorProgram"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAmountAssetWithdrawn"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "vaultAssetIdleAtaAmountBefore"; type: "u64" },
                    { name: "vaultAssetIdleAtaAmountAfter"; type: "u64" },
                    { name: "strategyPositionValueBefore"; type: "u64" },
                    { name: "strategyPositionValueAfter"; type: "u64" },
                    { name: "withdrawnTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
        {
            name: "withdrawVaultEvent";
            type: {
                fields: [
                    { name: "user"; type: "pubkey" },
                    { name: "userAmountAssetWithdrawn"; type: "u64" },
                    { name: "userAmountLpBurned"; type: "u64" },
                    { name: "vault"; type: "pubkey" },
                    { name: "vaultAssetMint"; type: "pubkey" },
                    { name: "vaultAssetTotalValueUnlockedBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueBefore"; type: "u64" },
                    { name: "vaultAssetTotalValueAfter"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesBefore"; type: "u64" },
                    { name: "vaultLpSupplyInclFeesAfter"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesBefore"; type: "u64" },
                    { name: "vaultLpTotalAccumulatedFeesAfter"; type: "u64" },
                    { name: "vaultLpDeadWeightBefore"; type: "u64" },
                    { name: "vaultLpDeadWeightAfter"; type: "u64" },
                    { name: "vaultHighestAssetPerLpDecimalBitsBefore"; type: "u128" },
                    { name: "vaultHighestAssetPerLpDecimalBitsAfter"; type: "u128" },
                    { name: "withdrawnTs"; type: "u64" },
                ];
                kind: "struct";
            };
        },
    ];
}