@zebec-network/zebec-stream-sdk 1.0.0

package/dist/artifacts/zebec_stream.d.ts

@@ -0,0 +1,1307 @@
+/**
+ * Program IDL in camelCase format in order to be used in JS/TS.
+ *
+ * Note that this is only a type helper and is not the actual IDL. The original
+ * IDL can be found at `target/idl/zebec_stream.json`.
+ */
+export type ZebecStream = {
+    address: "GoqwQ8CeFB3KEQgVQtnJzUAMz6zHMpCdeG785PD459W6";
+    metadata: {
+        name: "zebecStream";
+        version: "0.1.0";
+        spec: "0.1.0";
+        description: "Created with Anchor";
+    };
+    instructions: [
+        {
+            name: "cancelStream";
+            discriminator: [218, 221, 38, 25, 177, 207, 188, 91];
+            accounts: [
+                {
+                    name: "signer";
+                    docs: ["The sender or authorized party who initiated the stream, must be signer"];
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "feePayer";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "otherPartyAta";
+                    docs: ["Receiver's associated token account (auto-created if needed)"];
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "otherParty";
+                            },
+                            {
+                                kind: "const";
+                                value: [
+                                    6,
+                                    221,
+                                    246,
+                                    225,
+                                    215,
+                                    101,
+                                    161,
+                                    147,
+                                    217,
+                                    203,
+                                    225,
+                                    70,
+                                    206,
+                                    235,
+                                    121,
+                                    172,
+                                    28,
+                                    180,
+                                    133,
+                                    237,
+                                    95,
+                                    91,
+                                    55,
+                                    145,
+                                    58,
+                                    140,
+                                    245,
+                                    133,
+                                    126,
+                                    255,
+                                    0,
+                                    169
+                                ];
+                            },
+                            {
+                                kind: "account";
+                                path: "streamToken";
+                            }
+                        ];
+                        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
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: "otherParty";
+                    docs: ["Main receiver account for verification (read-only)"];
+                },
+                {
+                    name: "streamMetadata";
+                    docs: ["Stream payment metadata, mutable because cancellation updates state"];
+                    writable: true;
+                },
+                {
+                    name: "streamVault";
+                    docs: ["Vault PDA holding stream tokens"];
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "streamMetadata";
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "streamVaultAta";
+                    docs: ["Token account owned by the vault holding tokens for the stream"];
+                    writable: true;
+                },
+                {
+                    name: "signerAta";
+                    docs: ["Sender's token account to receive refunded tokens on cancel"];
+                    writable: true;
+                },
+                {
+                    name: "streamToken";
+                    docs: ["Mint of the stream token"];
+                },
+                {
+                    name: "tokenProgram";
+                    docs: ["Required Programs"];
+                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+                },
+                {
+                    name: "associatedTokenProgram";
+                    address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "changeRecipient";
+            discriminator: [232, 88, 141, 180, 224, 181, 25, 161];
+            accounts: [
+                {
+                    name: "signer";
+                    signer: true;
+                },
+                {
+                    name: "stream";
+                    writable: true;
+                },
+                {
+                    name: "newRecipient";
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "createStream";
+            discriminator: [71, 188, 111, 127, 108, 40, 229, 158];
+            accounts: [
+                {
+                    name: "sender";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "feePayer";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "senderAta";
+                    writable: true;
+                },
+                {
+                    name: "receiver";
+                    writable: true;
+                },
+                {
+                    name: "receiverAta";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "receiver";
+                            },
+                            {
+                                kind: "const";
+                                value: [
+                                    6,
+                                    221,
+                                    246,
+                                    225,
+                                    215,
+                                    101,
+                                    161,
+                                    147,
+                                    217,
+                                    203,
+                                    225,
+                                    70,
+                                    206,
+                                    235,
+                                    121,
+                                    172,
+                                    28,
+                                    180,
+                                    133,
+                                    237,
+                                    95,
+                                    91,
+                                    55,
+                                    145,
+                                    58,
+                                    140,
+                                    245,
+                                    133,
+                                    126,
+                                    255,
+                                    0,
+                                    169
+                                ];
+                            },
+                            {
+                                kind: "account";
+                                path: "streamToken";
+                            }
+                        ];
+                        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
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: "streamMetadata";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "streamVault";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "streamMetadata";
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "streamVaultAta";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "streamVault";
+                            },
+                            {
+                                kind: "const";
+                                value: [
+                                    6,
+                                    221,
+                                    246,
+                                    225,
+                                    215,
+                                    101,
+                                    161,
+                                    147,
+                                    217,
+                                    203,
+                                    225,
+                                    70,
+                                    206,
+                                    235,
+                                    121,
+                                    172,
+                                    28,
+                                    180,
+                                    133,
+                                    237,
+                                    95,
+                                    91,
+                                    55,
+                                    145,
+                                    58,
+                                    140,
+                                    245,
+                                    133,
+                                    126,
+                                    255,
+                                    0,
+                                    169
+                                ];
+                            },
+                            {
+                                kind: "account";
+                                path: "streamToken";
+                            }
+                        ];
+                        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
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: "streamConfig";
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "withdrawAccount";
+                    writable: true;
+                },
+                {
+                    name: "streamToken";
+                },
+                {
+                    name: "tokenProgram";
+                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+                },
+                {
+                    name: "associatedTokenProgram";
+                    address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [
+                {
+                    name: "params";
+                    type: {
+                        defined: {
+                            name: "createStreamParams";
+                        };
+                    };
+                }
+            ];
+        },
+        {
+            name: "initializeConfig";
+            discriminator: [208, 127, 21, 1, 194, 190, 196, 70];
+            accounts: [
+                {
+                    name: "admin";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "streamConfig";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [
+                {
+                    name: "params";
+                    type: {
+                        defined: {
+                            name: "initializeConfigParams";
+                        };
+                    };
+                }
+            ];
+        },
+        {
+            name: "pauseResumeStream";
+            discriminator: [173, 142, 243, 94, 154, 175, 5, 170];
+            accounts: [
+                {
+                    name: "user";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "streamMetadata";
+                    writable: true;
+                }
+            ];
+            args: [];
+        },
+        {
+            name: "whitelistTokens";
+            discriminator: [27, 206, 128, 157, 199, 65, 149, 189];
+            accounts: [
+                {
+                    name: "admin";
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "streamConfig";
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [
+                {
+                    name: "params";
+                    type: {
+                        defined: {
+                            name: "whitelistTokensParams";
+                        };
+                    };
+                }
+            ];
+        },
+        {
+            name: "withdrawStream";
+            discriminator: [211, 21, 90, 92, 185, 214, 88, 157];
+            accounts: [
+                {
+                    name: "withdrawer";
+                    docs: ["The receiver of the stream_metadata tokens, must sign to authorize withdrawal"];
+                    writable: true;
+                    signer: true;
+                },
+                {
+                    name: "receiver";
+                },
+                {
+                    name: "receiverAta";
+                    docs: ["Receiver's Associated Token Account (ATA) for receiving stream_metadata tokens"];
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "receiver";
+                            },
+                            {
+                                kind: "const";
+                                value: [
+                                    6,
+                                    221,
+                                    246,
+                                    225,
+                                    215,
+                                    101,
+                                    161,
+                                    147,
+                                    217,
+                                    203,
+                                    225,
+                                    70,
+                                    206,
+                                    235,
+                                    121,
+                                    172,
+                                    28,
+                                    180,
+                                    133,
+                                    237,
+                                    95,
+                                    91,
+                                    55,
+                                    145,
+                                    58,
+                                    140,
+                                    245,
+                                    133,
+                                    126,
+                                    255,
+                                    0,
+                                    169
+                                ];
+                            },
+                            {
+                                kind: "account";
+                                path: "streamToken";
+                            }
+                        ];
+                        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
+                            ];
+                        };
+                    };
+                },
+                {
+                    name: "streamMetadata";
+                    docs: ["Stream metadata loader, mutable because withdrawal updates state"];
+                    writable: true;
+                },
+                {
+                    name: "streamVault";
+                    docs: ["Vault PDA holding the pooled stream_metadata tokens"];
+                    writable: true;
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "account";
+                                path: "streamMetadata";
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "streamVaultAta";
+                    docs: ["Token account owned by the vault that holds the tokens to withdraw"];
+                    writable: true;
+                },
+                {
+                    name: "streamConfig";
+                    docs: ["Configuration account for the stream_metadata program"];
+                    pda: {
+                        seeds: [
+                            {
+                                kind: "const";
+                                value: [99, 111, 110, 102, 105, 103];
+                            }
+                        ];
+                    };
+                },
+                {
+                    name: "streamToken";
+                    docs: ["Mint info of the token being streamed"];
+                },
+                {
+                    name: "tokenProgram";
+                    docs: ["Required Programs"];
+                    address: "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+                },
+                {
+                    name: "associatedTokenProgram";
+                    address: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+                },
+                {
+                    name: "systemProgram";
+                    address: "11111111111111111111111111111111";
+                }
+            ];
+            args: [];
+        }
+    ];
+    accounts: [
+        {
+            name: "paymentStream";
+            discriminator: [124, 85, 193, 22, 93, 1, 143, 75];
+        },
+        {
+            name: "streamConfig";
+            discriminator: [130, 127, 218, 245, 133, 158, 70, 198];
+        }
+    ];
+    events: [
+        {
+            name: "streamCancelEvent";
+            discriminator: [155, 200, 221, 210, 40, 61, 207, 175];
+        },
+        {
+            name: "streamChangeRecipientEvent";
+            discriminator: [45, 42, 3, 230, 162, 49, 127, 81];
+        },
+        {
+            name: "streamCreateEvent";
+            discriminator: [55, 251, 103, 42, 227, 14, 96, 182];
+        },
+        {
+            name: "streamPauseResumeEvent";
+            discriminator: [252, 54, 142, 181, 13, 165, 61, 229];
+        },
+        {
+            name: "streamWithdrawEvent";
+            discriminator: [201, 202, 32, 160, 26, 199, 4, 70];
+        }
+    ];
+    errors: [
+        {
+            code: 6000;
+            name: "maxWhitelistedTokensExceeded";
+            msg: "Maximum number of whitelisted tokens (250) exceeded";
+        },
+        {
+            code: 6001;
+            name: "zeroStreamDuration";
+            msg: "Stream duration must be greater than zero";
+        },
+        {
+            code: 6002;
+            name: "invalidStreamAmount";
+            msg: "Stream amount must be greater than zero";
+        },
+        {
+            code: 6003;
+            name: "pastStartTime";
+            msg: "Start time is in the past";
+        },
+        {
+            code: 6004;
+            name: "invalidCliffPercentage";
+            msg: "Invalid cliff percentage";
+        },
+        {
+            code: 6005;
+            name: "tokenNotWhitelisted";
+            msg: "Token not whitelisted";
+        },
+        {
+            code: 6006;
+            name: "unknownStreamFrequency";
+            msg: "Stream frequency not included in stream configuration";
+        },
+        {
+            code: 6007;
+            name: "durationNotExactlyDivisibleByFrequency";
+            msg: "Stream Duration is not exactly divisible by the frequency";
+        },
+        {
+            code: 6008;
+            name: "insufficientSenderBalance";
+            msg: "Sender does not have enough balance to create the stream";
+        },
+        {
+            code: 6009;
+            name: "streamAlreadyCanceled";
+            msg: "Stream Already Canceled";
+        },
+        {
+            code: 6010;
+            name: "unauthorized";
+            msg: "Unauthorized: Only the allowed party can cancel the stream";
+        },
+        {
+            code: 6011;
+            name: "notCancellable";
+            msg: "Stream is not Cancellable";
+        },
+        {
+            code: 6012;
+            name: "streamAlreadyWithdrawn";
+            msg: "Stream has already been withdrawn";
+        },
+        {
+            code: 6013;
+            name: "invalidReceiver";
+            msg: "UnAuthorized: Only the allowed party can transfer the stream";
+        },
+        {
+            code: 6014;
+            name: "streamAutoWithdrawable";
+            msg: "Stream is automatically withdrawable";
+        },
+        {
+            code: 6015;
+            name: "withdrawAmountExceeds";
+            msg: "Withdraw amount exceeds the available amount in the stream";
+        },
+        {
+            code: 6016;
+            name: "insufficientFundsToWithdraw";
+            msg: "Insufficient funds in the stream vault for withdrawal";
+        },
+        {
+            code: 6017;
+            name: "streamNotStarted";
+            msg: "Stream has not started yet";
+        },
+        {
+            code: 6018;
+            name: "noWithdrawableAmount";
+            msg: "No withdrawable amount available at this time";
+        },
+        {
+            code: 6019;
+            name: "invalidStreamToken";
+            msg: "Invalid stream token";
+        },
+        {
+            code: 6020;
+            name: "streamAlreadyEnded";
+            msg: "Stream already ended";
+        }
+    ];
+    types: [
+        {
+            name: "createStreamParams";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "sender";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "receiver";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "amount";
+                        type: "u64";
+                    },
+                    {
+                        name: "startTime";
+                        type: "i64";
+                    },
+                    {
+                        name: "duration";
+                        type: "u64";
+                    },
+                    {
+                        name: "streamFrequency";
+                        type: "u64";
+                    },
+                    {
+                        name: "cliffPercentage";
+                        type: "u64";
+                    },
+                    {
+                        name: "cancelableBySender";
+                        type: "u8";
+                    },
+                    {
+                        name: "cancelableByRecipient";
+                        type: "u8";
+                    },
+                    {
+                        name: "automaticWithdrawal";
+                        type: "u8";
+                    },
+                    {
+                        name: "transferableBySender";
+                        type: "u8";
+                    },
+                    {
+                        name: "transferableByRecipient";
+                        type: "u8";
+                    },
+                    {
+                        name: "canTopup";
+                        type: "u8";
+                    },
+                    {
+                        name: "isPausable";
+                        type: "u8";
+                    },
+                    {
+                        name: "rateUpdatable";
+                        type: "u8";
+                    },
+                    {
+                        name: "startNow";
+                        type: "u8";
+                    },
+                    {
+                        name: "streamName";
+                        type: {
+                            array: ["u8", 128];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "initializeConfigParams";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "withdrawAccount";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "platformFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "baseFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "frequencies";
+                        type: {
+                            vec: "u64";
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "paymentStream";
+            serialization: "bytemuck";
+            repr: {
+                kind: "c";
+            };
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "parties";
+                        type: {
+                            defined: {
+                                name: "streamParties";
+                            };
+                        };
+                    },
+                    {
+                        name: "financials";
+                        type: {
+                            defined: {
+                                name: "streamFinancials";
+                            };
+                        };
+                    },
+                    {
+                        name: "schedule";
+                        type: {
+                            defined: {
+                                name: "streamSchedule";
+                            };
+                        };
+                    },
+                    {
+                        name: "permissions";
+                        type: {
+                            defined: {
+                                name: "streamPermissions";
+                            };
+                        };
+                    },
+                    {
+                        name: "streamName";
+                        type: {
+                            array: ["u8", 128];
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamCancelEvent";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "stream";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "canceledBy";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "sentToRecipient";
+                        type: "u64";
+                    },
+                    {
+                        name: "sentToSender";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamChangeRecipientEvent";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "stream";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "newRecipient";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "oldRecipient";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "changedBy";
+                        type: "pubkey";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamConfig";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "admin";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "withdrawAccount";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "whitelistedTokens";
+                        type: {
+                            vec: "pubkey";
+                        };
+                    },
+                    {
+                        name: "platformFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "baseFee";
+                        type: "u64";
+                    },
+                    {
+                        name: "frequencies";
+                        type: {
+                            vec: "u64";
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamCreateEvent";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "stream";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "creator";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "transactionFee";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamFinancials";
+            serialization: "bytemuck";
+            repr: {
+                kind: "c";
+            };
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "cliffPercentage";
+                        type: "u64";
+                    },
+                    {
+                        name: "depositedAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "withdrawnAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "streamToken";
+                        type: "pubkey";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamParties";
+            serialization: "bytemuck";
+            repr: {
+                kind: "c";
+            };
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "sender";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "receiver";
+                        type: "pubkey";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamPauseResumeEvent";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "stream";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "initiator";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "paused";
+                        type: "bool";
+                    },
+                    {
+                        name: "pausedDuration";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamPermissions";
+            serialization: "bytemuck";
+            repr: {
+                kind: "c";
+            };
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "cancelableBySender";
+                        type: "u8";
+                    },
+                    {
+                        name: "cancelableByRecipient";
+                        type: "u8";
+                    },
+                    {
+                        name: "automaticWithdrawal";
+                        type: "u8";
+                    },
+                    {
+                        name: "transferableBySender";
+                        type: "u8";
+                    },
+                    {
+                        name: "transferableByRecipient";
+                        type: "u8";
+                    },
+                    {
+                        name: "canTopup";
+                        type: "u8";
+                    },
+                    {
+                        name: "isPausable";
+                        type: "u8";
+                    },
+                    {
+                        name: "rateUpdatable";
+                        type: "u8";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamSchedule";
+            serialization: "bytemuck";
+            repr: {
+                kind: "c";
+            };
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "startTime";
+                        type: "i64";
+                    },
+                    {
+                        name: "endTime";
+                        type: "i64";
+                    },
+                    {
+                        name: "lastWithdrawTime";
+                        type: "i64";
+                    },
+                    {
+                        name: "frequency";
+                        type: "u64";
+                    },
+                    {
+                        name: "duration";
+                        type: "u64";
+                    },
+                    {
+                        name: "pausedTimestamp";
+                        type: "i64";
+                    },
+                    {
+                        name: "pausedInterval";
+                        type: "i64";
+                    },
+                    {
+                        name: "canceledTimestamp";
+                        type: "i64";
+                    }
+                ];
+            };
+        },
+        {
+            name: "streamWithdrawEvent";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "stream";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "withdrawer";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "recipient";
+                        type: "pubkey";
+                    },
+                    {
+                        name: "amount";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
+        {
+            name: "whitelistTokensParams";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "tokens";
+                        type: {
+                            vec: "pubkey";
+                        };
+                    }
+                ];
+            };
+        }
+    ];
+    constants: [
+        {
+            name: "seed";
+            type: "string";
+            value: '"anchor"';
+        }
+    ];
+};