@zebec-network/zebec-stream-sdk 2.1.0 → 3.0.0-dev.2

package/dist/artifacts/zebec_stream.d.ts

@@ -407,6 +407,11 @@ export type ZebecStream = {
                             {
                                 kind: "const";
                                 value: [99, 111, 110, 102, 105, 103];
+                            },
+                            {
+                                kind: "account";
+                                path: "stream_config.config_name";
+                                account: "streamConfig";
                             }
                         ];
                     };
@@ -459,6 +464,10 @@ export type ZebecStream = {
                             {
                                 kind: "const";
                                 value: [99, 111, 110, 102, 105, 103];
+                            },
+                            {
+                                kind: "arg";
+                                path: "params.config_name";
                             }
                         ];
                     };
@@ -512,6 +521,11 @@ export type ZebecStream = {
                             {
                                 kind: "const";
                                 value: [99, 111, 110, 102, 105, 103];
+                            },
+                            {
+                                kind: "account";
+                                path: "stream_config.config_name";
+                                account: "streamConfig";
                             }
                         ];
                     };
@@ -549,6 +563,11 @@ export type ZebecStream = {
                             {
                                 kind: "const";
                                 value: [99, 111, 110, 102, 105, 103];
+                            },
+                            {
+                                kind: "account";
+                                path: "stream_config.config_name";
+                                account: "streamConfig";
                             }
                         ];
                     };
@@ -703,6 +722,11 @@ export type ZebecStream = {
                             {
                                 kind: "const";
                                 value: [99, 111, 110, 102, 105, 103];
+                            },
+                            {
+                                kind: "account";
+                                path: "stream_config.config_name";
+                                account: "streamConfig";
                             }
                         ];
                     };
@@ -964,11 +988,53 @@ export type ZebecStream = {
                 ];
             };
         },
+        {
+            name: "feeMap";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "tiers";
+                        type: {
+                            vec: {
+                                defined: {
+                                    name: "feeTier";
+                                };
+                            };
+                        };
+                    }
+                ];
+            };
+        },
+        {
+            name: "feeTier";
+            type: {
+                kind: "struct";
+                fields: [
+                    {
+                        name: "minAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "maxAmount";
+                        type: "u64";
+                    },
+                    {
+                        name: "fee";
+                        type: "u64";
+                    }
+                ];
+            };
+        },
         {
             name: "initializeConfigParams";
             type: {
                 kind: "struct";
                 fields: [
+                    {
+                        name: "configName";
+                        type: "string";
+                    },
                     {
                         name: "withdrawAccount";
                         type: "pubkey";
@@ -986,6 +1052,20 @@ export type ZebecStream = {
                         type: {
                             vec: "u64";
                         };
+                    },
+                    {
+                        name: "feeTier";
+                        type: {
+                            vec: {
+                                defined: {
+                                    name: "feeTier";
+                                };
+                            };
+                        };
+                    },
+                    {
+                        name: "feeVault";
+                        type: "pubkey";
                     }
                 ];
             };
@@ -1117,6 +1197,10 @@ export type ZebecStream = {
             type: {
                 kind: "struct";
                 fields: [
+                    {
+                        name: "configName";
+                        type: "string";
+                    },
                     {
                         name: "admin";
                         type: "pubkey";
@@ -1144,6 +1228,18 @@ export type ZebecStream = {
                         type: {
                             vec: "u64";
                         };
+                    },
+                    {
+                        name: "feeTiers";
+                        type: {
+                            defined: {
+                                name: "feeMap";
+                            };
+                        };
+                    },
+                    {
+                        name: "feeVault";
+                        type: "pubkey";
                     }
                 ];
             };

package/dist/artifacts/zebec_stream.json

@@ -367,6 +367,11 @@
                             {
                                 "kind": "const",
                                 "value": [99, 111, 110, 102, 105, 103]
+                            },
+                            {
+                                "account": "StreamConfig",
+                                "kind": "account",
+                                "path": "stream_config.config_name"
                             }
                         ]
                     }
@@ -418,6 +423,10 @@
                             {
                                 "kind": "const",
                                 "value": [99, 111, 110, 102, 105, 103]
+                            },
+                            {
+                                "kind": "arg",
+                                "path": "params.config_name"
                             }
                         ]
                     },
@@ -471,6 +480,11 @@
                             {
                                 "kind": "const",
                                 "value": [99, 111, 110, 102, 105, 103]
+                            },
+                            {
+                                "account": "StreamConfig",
+                                "kind": "account",
+                                "path": "stream_config.config_name"
                             }
                         ]
                     },
@@ -508,6 +522,11 @@
                             {
                                 "kind": "const",
                                 "value": [99, 111, 110, 102, 105, 103]
+                            },
+                            {
+                                "account": "StreamConfig",
+                                "kind": "account",
+                                "path": "stream_config.config_name"
                             }
                         ]
                     },
@@ -603,6 +622,11 @@
                             {
                                 "kind": "const",
                                 "value": [99, 111, 110, 102, 105, 103]
+                            },
+                            {
+                                "account": "StreamConfig",
+                                "kind": "account",
+                                "path": "stream_config.config_name"
                             }
                         ]
                     }
@@ -725,10 +749,52 @@
                 "kind": "struct"
             }
         },
+        {
+            "name": "FeeMap",
+            "type": {
+                "fields": [
+                    {
+                        "name": "tiers",
+                        "type": {
+                            "vec": {
+                                "defined": {
+                                    "name": "FeeTier"
+                                }
+                            }
+                        }
+                    }
+                ],
+                "kind": "struct"
+            }
+        },
+        {
+            "name": "FeeTier",
+            "type": {
+                "fields": [
+                    {
+                        "name": "min_amount",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "max_amount",
+                        "type": "u64"
+                    },
+                    {
+                        "name": "fee",
+                        "type": "u64"
+                    }
+                ],
+                "kind": "struct"
+            }
+        },
         {
             "name": "InitializeConfigParams",
             "type": {
                 "fields": [
+                    {
+                        "name": "config_name",
+                        "type": "string"
+                    },
                     {
                         "name": "withdraw_account",
                         "type": "pubkey"
@@ -746,6 +812,20 @@
                         "type": {
                             "vec": "u64"
                         }
+                    },
+                    {
+                        "name": "fee_tier",
+                        "type": {
+                            "vec": {
+                                "defined": {
+                                    "name": "FeeTier"
+                                }
+                            }
+                        }
+                    },
+                    {
+                        "name": "fee_vault",
+                        "type": "pubkey"
                     }
                 ],
                 "kind": "struct"
@@ -877,6 +957,10 @@
             "name": "StreamConfig",
             "type": {
                 "fields": [
+                    {
+                        "name": "config_name",
+                        "type": "string"
+                    },
                     {
                         "name": "admin",
                         "type": "pubkey"
@@ -904,6 +988,18 @@
                         "type": {
                             "vec": "u64"
                         }
+                    },
+                    {
+                        "name": "fee_tiers",
+                        "type": {
+                            "defined": {
+                                "name": "FeeMap"
+                            }
+                        }
+                    },
+                    {
+                        "name": "fee_vault",
+                        "type": "pubkey"
                     }
                 ],
                 "kind": "struct"

package/dist/constants.d.ts

@@ -1,4 +1,5 @@
+import type { RpcNetwork } from "./types";
 export declare const STREAM_NAME_BUFFER_SIZE = 128;
-export type Network = "mainnet-beta" | "devnet";
-export declare const STREAM_PROGRAM_ID: Record<Network, string>;
-export declare const STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS: Record<Network, string>;
+export declare const STREAM_PROGRAM_ID: Record<RpcNetwork, string>;
+export declare const STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS: Record<RpcNetwork, string>;
+export declare const SUPERAPP_BACKEND_URL: Record<RpcNetwork, string>;

package/dist/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS = exports.STREAM_PROGRAM_ID = exports.STREAM_NAME_BUFFER_SIZE = void 0;
+exports.SUPERAPP_BACKEND_URL = exports.STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS = exports.STREAM_PROGRAM_ID = exports.STREAM_NAME_BUFFER_SIZE = void 0;
 exports.STREAM_NAME_BUFFER_SIZE = 128;
 exports.STREAM_PROGRAM_ID = {
     "mainnet-beta": "zSTRMmYcFF8SPdHmsAmAUjBnx4zDHvnqqGz2mPcc5QC",
@@ -10,3 +10,7 @@ exports.STREAM_PROGRAM_LOOKUP_TABLE_ADDRESS = {
     devnet: "HJmEzSXzJrtSdgBZSaedQ51WaD4LkT1r5zR2yT1QERqv",
     "mainnet-beta": "43N5otEu7k7TzkKsdhkwiYGrdKjBejetWQbF9cJPtY6i",
 };
+exports.SUPERAPP_BACKEND_URL = {
+    "mainnet-beta": "https://superapp-backend.zebec.io",
+    devnet: "https://dev-super.api.zebec.io",
+};

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from "./services";
 export * from "./pda";
 export * from "./providers";
 export * from "./types";
+export * from "./utils";

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./services"), exports);
 __exportStar(require("./pda"), exports);
 __exportStar(require("./providers"), exports);
 __exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/pda.d.ts

@@ -1,4 +1,4 @@
-import { Address } from "@coral-xyz/anchor";
+import { type Address } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-export declare function deriveStreamConfigPda(programId: Address): [PublicKey, number];
+export declare function deriveStreamConfigPda(configName: string, programId: Address): [PublicKey, number];
 export declare function deriveStreamVaultPda(metatadata: Address, programId: Address): [PublicKey, number];

package/dist/pda.js

@@ -7,8 +7,8 @@ const web3_js_1 = require("@solana/web3.js");
 const SEEDS = {
     STREAM_CONFIG: anchor_1.utils.bytes.utf8.encode("config"),
 };
-function deriveStreamConfigPda(programId) {
-    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.STREAM_CONFIG)], (0, anchor_1.translateAddress)(programId));
+function deriveStreamConfigPda(configName, programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.STREAM_CONFIG), anchor_1.utils.bytes.utf8.encode(configName)], (0, anchor_1.translateAddress)(programId));
 }
 function deriveStreamVaultPda(metatadata, programId) {
     return web3_js_1.PublicKey.findProgramAddressSync([(0, anchor_1.translateAddress)(metatadata).toBuffer()], (0, anchor_1.translateAddress)(programId));

package/dist/services/streamService.d.ts

@@ -1,28 +1,42 @@
-import { Address, BN, Program, Provider } from "@coral-xyz/anchor";
-import { Commitment, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { type Address, BN, Program, type Provider } from "@coral-xyz/anchor";
+import { type Commitment, type Connection, PublicKey, type TransactionInstruction } from "@solana/web3.js";
 import { TransactionPayload } from "@zebec-network/solana-common";
-import { ZebecStreamIdl } from "../artifacts";
-import { Numeric, StreamConfigInfo, StreamMetadataInfo, TokenMetadata } from "../types";
+import { type ZebecStreamIdl } from "../artifacts";
+import type { CancelStreamParams, ChangeStreamReceiverParams, CreateStreamParams, InitializeStreamConfigParams, RpcNetwork, StreamConfigInfo, StreamMetadataInfo, TokenMetadata, UpdateStreamConfigParams, WhiteListTokensParams, WithdrawStreamParams } from "../types";
 export declare class ZebecStreamService {
     readonly provider: Provider;
-    readonly network: "mainnet-beta" | "devnet";
+    readonly network: RpcNetwork;
     readonly program: Program<ZebecStreamIdl>;
-    constructor(provider: Provider, network: "mainnet-beta" | "devnet", program: Program<ZebecStreamIdl>);
-    static create(provider: Provider, network: "mainnet-beta" | "devnet"): ZebecStreamService;
+    constructor(provider: Provider, network: RpcNetwork, program: Program<ZebecStreamIdl>);
+    static create(provider: Provider, network: RpcNetwork): ZebecStreamService;
     private _createPayload;
     get connection(): Connection;
     get programId(): PublicKey;
-    getInitializeStreamConfigInstruction(admin: PublicKey, config: {
+    getInitializeStreamConfigInstruction(admin: PublicKey, streamConfig: PublicKey, config: {
         baseFee: BN;
         frequencies: BN[];
         platformFee: BN;
         withdrawAccount: PublicKey;
+        configName: string;
+        feeTiers: {
+            minAmount: BN;
+            maxAmount: BN;
+            fee: BN;
+        }[];
+        feeVault: PublicKey;
     }): Promise<TransactionInstruction>;
-    getUpdateStreamConfigInstruction(admin: PublicKey, config: {
+    getUpdateStreamConfigInstruction(admin: PublicKey, streamConfig: PublicKey, config: {
         baseFee: BN;
         frequencies: BN[];
         platformFee: BN;
         withdrawAccount: PublicKey;
+        configName: string;
+        feeTiers: {
+            minAmount: BN;
+            maxAmount: BN;
+            fee: BN;
+        }[];
+        feeVault: PublicKey;
     }): Promise<TransactionInstruction>;
     getCreateStreamInstruction(feePayer: PublicKey, receiver: PublicKey, senderAta: PublicKey, streamToken: PublicKey, withdrawAccount: PublicKey, sender: PublicKey, streamMetadata: PublicKey, streamData: {
         amount: BN;
@@ -56,70 +70,7 @@ export declare class ZebecStreamService {
     withdrawStream(params: WithdrawStreamParams): Promise<TransactionPayload>;
     whiteListTokens(params: WhiteListTokensParams): Promise<TransactionPayload>;
     changeStreamReceiver(params: ChangeStreamReceiverParams): Promise<TransactionPayload>;
-    getStreamConfigInfo(commitment?: Commitment): Promise<StreamConfigInfo>;
-    getWhitelistedTokens(commitment?: "processed" | "confirmed" | "finalized"): Promise<TokenMetadata[]>;
+    getStreamConfigInfo(configName: string, commitment?: Commitment): Promise<StreamConfigInfo>;
+    getWhitelistedTokens(configName: string, commitment?: "processed" | "confirmed" | "finalized"): Promise<TokenMetadata[]>;
     getStreamMetadataInfo(streamMetadata: Address, commitment?: Commitment): Promise<StreamMetadataInfo>;
 }
-export type CreateStreamParams = {
-    feePayer?: Address;
-    receiver: Address;
-    sender: Address;
-    streamToken: Address;
-    amount: Numeric;
-    automaticWithdrawal: boolean;
-    cancelableByRecipient: boolean;
-    cancelableBySender: boolean;
-    cliffPercentage: Numeric;
-    duration: number;
-    isPausable: boolean;
-    startNow: boolean;
-    startTime: number;
-    autoWithdrawFrequency: number;
-    streamName: string;
-    transferableByRecipient: boolean;
-    transferableBySender: boolean;
-    canTopup: boolean;
-    rateUpdatable: boolean;
-    streamMetadataKeypair?: Keypair;
-};
-export type InitializeStreamConfigParams = {
-    admin?: Address;
-    config: {
-        baseFeePercent: Numeric;
-        frequencies: number[];
-        platformFeePercent: Numeric;
-        withdrawAccount: Address;
-    };
-};
-export type UpdateStreamConfigParams = {
-    admin?: Address;
-    config: {
-        baseFeePercent: Numeric;
-        frequencies: number[];
-        platformFeePercent: Numeric;
-        withdrawAccount: Address;
-    };
-};
-export type CancelStreamParams = {
-    feePayer?: Address;
-    streamMetadata: Address;
-    user: Address;
-};
-export type PauseResumeStreamParams = {
-    streamMetadata: Address;
-};
-export type WithdrawStreamParams = {
-    streamMetadata: Address;
-    withdrawer?: Address;
-    feePayer?: Address;
-    receiver: Address;
-};
-export type WhiteListTokensParams = {
-    admin: Address;
-    tokens: Address[];
-};
-export type ChangeStreamReceiverParams = {
-    streamMetadata: Address;
-    newRecipient: Address;
-    signer: Address;
-};

package/dist/services/streamService.js

@@ -4,18 +4,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ZebecStreamService = void 0;
-const assert_1 = __importDefault(require("assert"));
-const bignumber_js_1 = require("bignumber.js");
 const anchor_1 = require("@coral-xyz/anchor");
 const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
 const umi_bundle_defaults_1 = require("@metaplex-foundation/umi-bundle-defaults");
 const umi_web3js_adapters_1 = require("@metaplex-foundation/umi-web3js-adapters");
+const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
 const core_utils_1 = require("@zebec-network/core-utils");
 const solana_common_1 = require("@zebec-network/solana-common");
+const assert_1 = __importDefault(require("assert"));
+const bignumber_js_1 = require("bignumber.js");
 const artifacts_1 = require("../artifacts");
 const constants_1 = require("../constants");
 const pda_1 = require("../pda");
+const utils_1 = require("../utils");
 class ZebecStreamService {
     provider;
     network;
@@ -44,7 +46,7 @@ class ZebecStreamService {
     }
     async _createPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
         const errorMap = new Map();
-        this.program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        this.program.idl.errors.map((error) => errorMap.set(error.code, error.msg));
         const provider = this.provider;
         let signTransaction;
         if (provider instanceof anchor_1.AnchorProvider) {
@@ -65,29 +67,37 @@ class ZebecStreamService {
     get programId() {
         return this.program.programId;
     }
-    async getInitializeStreamConfigInstruction(admin, config) {
+    async getInitializeStreamConfigInstruction(admin, streamConfig, config) {
         return this.program.methods
             .initializeConfig({
             baseFee: config.baseFee,
             frequencies: config.frequencies,
             platformFee: config.platformFee,
             withdrawAccount: config.withdrawAccount,
+            configName: config.configName,
+            feeTier: config.feeTiers,
+            feeVault: config.feeVault,
         })
-            .accounts({
+            .accountsPartial({
             admin,
+            streamConfig,
         })
             .instruction();
     }
-    async getUpdateStreamConfigInstruction(admin, config) {
+    async getUpdateStreamConfigInstruction(admin, streamConfig, config) {
         return this.program.methods
             .updateConfig({
             baseFee: config.baseFee,
             frequencies: config.frequencies,
             platformFee: config.platformFee,
             withdrawAccount: config.withdrawAccount,
+            configName: config.configName,
+            feeTier: config.feeTiers,
+            feeVault: config.feeVault,
         })
-            .accounts({
+            .accountsPartial({
             admin,
+            streamConfig,
         })
             .instruction();
     }
@@ -187,15 +197,27 @@ class ZebecStreamService {
         if (!admin) {
             throw new Error("Either provide admin or create provider with public key");
         }
+        const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(params.config.configName, this.programId);
         const baseFee = new anchor_1.BN((0, core_utils_1.percentToBps)(params.config.baseFeePercent));
         const frequencies = params.config.frequencies.map((frequency) => new anchor_1.BN(frequency));
         const platformFee = new anchor_1.BN((0, core_utils_1.percentToBps)(params.config.platformFeePercent));
         const withdrawAccount = (0, anchor_1.translateAddress)(params.config.withdrawAccount);
-        const ix = await this.getInitializeStreamConfigInstruction(admin, {
+        const feeVault = (0, anchor_1.translateAddress)(params.config.feeVault);
+        const feeTiers = params.config.feeTiers.map((tier) => {
+            return {
+                minAmount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(tier.minThreshold).times(solana_common_1.TEN_BIGNUM.pow(solana_common_1.USDC_DECIMALS)).toFixed(0)),
+                maxAmount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(tier.maxThreshold).times(solana_common_1.TEN_BIGNUM.pow(solana_common_1.USDC_DECIMALS)).toFixed(0)),
+                fee: new anchor_1.BN((0, core_utils_1.percentToBps)(tier.feeRateInPercent)),
+            };
+        });
+        const ix = await this.getInitializeStreamConfigInstruction(admin, streamConfig, {
             baseFee,
             frequencies,
             platformFee,
             withdrawAccount,
+            feeTiers,
+            configName: params.config.configName,
+            feeVault,
         });
         return this._createPayload(admin, [ix]);
     }
@@ -204,15 +226,27 @@ class ZebecStreamService {
         if (!admin) {
             throw new Error("Either provide admin or create provider with public key");
         }
+        const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(params.config.configName, this.programId);
         const baseFee = new anchor_1.BN((0, core_utils_1.percentToBps)(params.config.baseFeePercent));
         const frequencies = params.config.frequencies.map((frequency) => new anchor_1.BN(frequency));
         const platformFee = new anchor_1.BN((0, core_utils_1.percentToBps)(params.config.platformFeePercent));
         const withdrawAccount = (0, anchor_1.translateAddress)(params.config.withdrawAccount);
-        const ix = await this.getUpdateStreamConfigInstruction(admin, {
+        const feeVault = (0, anchor_1.translateAddress)(params.config.feeVault);
+        const feeTiers = params.config.feeTiers.map((tier) => {
+            return {
+                minAmount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(tier.minThreshold).times(solana_common_1.TEN_BIGNUM.pow(solana_common_1.USDC_DECIMALS)).toFixed(0)),
+                maxAmount: new anchor_1.BN((0, bignumber_js_1.BigNumber)(tier.maxThreshold).times(solana_common_1.TEN_BIGNUM.pow(solana_common_1.USDC_DECIMALS)).toFixed(0)),
+                fee: new anchor_1.BN((0, core_utils_1.percentToBps)(tier.feeRateInPercent)),
+            };
+        });
+        const ix = await this.getUpdateStreamConfigInstruction(admin, streamConfig, {
             baseFee,
             frequencies,
             platformFee,
             withdrawAccount,
+            feeTiers,
+            configName: params.config.configName,
+            feeVault,
         });
         return this._createPayload(admin, [ix]);
     }
@@ -221,7 +255,7 @@ class ZebecStreamService {
         const sender = (0, anchor_1.translateAddress)(params.sender);
         const feePayer = params.feePayer ? (0, anchor_1.translateAddress)(params.feePayer) : sender;
         const streamToken = (0, anchor_1.translateAddress)(params.streamToken);
-        const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(this.programId);
+        const [streamConfig] = (0, pda_1.deriveStreamConfigPda)(params.configName, this.programId);
         const streamConfigAccount = await this.program.account.streamConfig.fetch(streamConfig);
         const withdrawer = streamConfigAccount.withdrawAccount;
         const autoWithdrawFrequencies = new Set(Array.from(streamConfigAccount.frequencies.map((f) => f.toNumber())));
@@ -231,12 +265,35 @@ class ZebecStreamService {
         const senderAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, sender, true);
         const streamMetadataKeypair = params.streamMetadataKeypair ?? web3_js_1.Keypair.generate();
         const streamTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, streamToken);
-        const amount = new anchor_1.BN((0, bignumber_js_1.BigNumber)(params.amount).times(solana_common_1.TEN_BIGNUM.pow(streamTokenDecimals)).toFixed(0));
+        const amount = (0, bignumber_js_1.BigNumber)(params.amount).times(solana_common_1.TEN_BIGNUM.pow(streamTokenDecimals)).toFixed(0);
         const cliffPercentage = new anchor_1.BN((0, core_utils_1.percentToBps)(params.cliffPercentage));
         const streamName = new Uint8Array(constants_1.STREAM_NAME_BUFFER_SIZE);
         streamName.set(anchor_1.utils.bytes.utf8.encode(params.streamName));
-        const ix = await this.getCreateStreamInstruction(feePayer, receiver, senderAta, streamToken, withdrawer, sender, streamMetadataKeypair.publicKey, {
-            amount,
+        const configAccount = await this.program.account.streamConfig.fetch(streamConfig);
+        const feeTiers = configAccount.feeTiers.tiers.map((tier) => ({
+            feeRateInPercent: (0, core_utils_1.bpsToPercent)(tier.fee.toNumber()),
+            minThreshold: (0, bignumber_js_1.BigNumber)(tier.minAmount.toString()).div(solana_common_1.UNITS_PER_USDC).toFixed(),
+            maxThreshold: (0, bignumber_js_1.BigNumber)(tier.maxAmount.toString()).div(solana_common_1.UNITS_PER_USDC).toFixed(),
+        }));
+        const feeAmount = await (0, utils_1.calculateFeeTokenAmountForStream)(params.streamTokenSymbol, params.amount, params.feeTokenSymbol, feeTiers, this.network);
+        const feeToken = (0, anchor_1.translateAddress)(params.feeToken);
+        const feeTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, feeToken);
+        const parsedFeeAmount = (0, bignumber_js_1.BigNumber)(feeAmount).times(solana_common_1.TEN_BIGNUM.pow(feeTokenDecimals)).toFixed(0);
+        const feeVault = configAccount.feeVault;
+        const feeVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(feeToken, feeVault, true);
+        const senderFeeTokenAta = (0, solana_common_1.getAssociatedTokenAddressSync)(feeToken, sender, true);
+        const feeVaultAtaInfo = await this.connection.getAccountInfo(feeVaultAta);
+        const ixs = [];
+        // add instruction to create fee vault ATA if it does not exist
+        if (!feeVaultAtaInfo) {
+            const createFeeVaultAtaIx = (0, solana_common_1.createAssociatedTokenAccountInstruction)(feePayer, feeVaultAta, feeVault, feeToken);
+            ixs.push(createFeeVaultAtaIx);
+        }
+        // add instruction to transfer fee to fee vault
+        const transferFeeToVaultIx = (0, spl_token_1.createTransferInstruction)(senderFeeTokenAta, feeVaultAta, sender, BigInt(parsedFeeAmount));
+        ixs.push(transferFeeToVaultIx);
+        const createStreamIx = await this.getCreateStreamInstruction(feePayer, receiver, senderAta, streamToken, withdrawer, sender, streamMetadataKeypair.publicKey, {
+            amount: new anchor_1.BN(amount),
             automaticWithdrawal: params.automaticWithdrawal,
             cancelableByRecipient: params.cancelableByRecipient,
             cancelableBySender: params.cancelableBySender,
@@ -252,7 +309,8 @@ class ZebecStreamService {
             transferableByRecipient: params.transferableByRecipient,
             transferableBySender: params.transferableBySender,
         });
-        return this._createPayload(feePayer, [ix], [streamMetadataKeypair]);
+        ixs.push(createStreamIx);
+        return this._createPayload(feePayer, ixs, [streamMetadataKeypair]);
     }
     async cancelStream(params) {
         const user = (0, anchor_1.translateAddress)(params.user);
@@ -312,8 +370,8 @@ class ZebecStreamService {
         const ix = await this.getChangeStreamReceiverInstruction(streamMetadata, newRecipient, signer);
         return this._createPayload(signer, [ix]);
     }
-    async getStreamConfigInfo(commitment) {
-        const [config] = (0, pda_1.deriveStreamConfigPda)(this.programId);
+    async getStreamConfigInfo(configName, commitment) {
+        const [config] = (0, pda_1.deriveStreamConfigPda)(configName, this.programId);
         const configInfo = await this.program.account.streamConfig.fetch(config, commitment ?? this.connection.commitment);
         return {
             address: config,
@@ -323,10 +381,16 @@ class ZebecStreamService {
             platformFee: Number((0, core_utils_1.bpsToPercent)(configInfo.platformFee.toNumber())),
             baseFee: Number((0, core_utils_1.bpsToPercent)(configInfo.baseFee.toNumber())),
             frequencies: configInfo.frequencies.map((frequency) => frequency.toNumber()),
+            feeTiers: configInfo.feeTiers.tiers.map((tier) => ({
+                feeRateInPercent: (0, core_utils_1.bpsToPercent)(tier.fee.toNumber()),
+                minThreshold: (0, bignumber_js_1.BigNumber)(tier.minAmount.toString()).div(solana_common_1.UNITS_PER_USDC).toFixed(),
+                maxThreshold: (0, bignumber_js_1.BigNumber)(tier.maxAmount.toString()).div(solana_common_1.UNITS_PER_USDC).toFixed(),
+            })),
+            feeVault: configInfo.feeVault,
         };
     }
-    async getWhitelistedTokens(commitment) {
-        const [config] = (0, pda_1.deriveStreamConfigPda)(this.programId);
+    async getWhitelistedTokens(configName, commitment) {
+        const [config] = (0, pda_1.deriveStreamConfigPda)(configName, this.programId);
         const configInfo = await this.program.account.streamConfig.fetch(config, commitment ?? this.connection.commitment);
         const whitelistedTokens = configInfo.whitelistedTokens;
         const umi = (0, umi_bundle_defaults_1.createUmi)(this.connection.rpcEndpoint, commitment);

package/dist/types.d.ts

@@ -1,4 +1,6 @@
-import { PublicKey } from "@solana/web3.js";
+import type { Address } from "@coral-xyz/anchor";
+import type { Keypair, PublicKey } from "@solana/web3.js";
+export type RpcNetwork = "mainnet-beta" | "devnet";
 export type Numeric = string | number;
 export type StreamConfigInfo = {
     address: PublicKey;
@@ -8,6 +10,8 @@ export type StreamConfigInfo = {
     platformFee: number;
     baseFee: number;
     frequencies: number[];
+    feeTiers: FeeTier[];
+    feeVault: PublicKey;
 };
 export type StreamMetadataInfo = {
     address: PublicKey;
@@ -58,3 +62,81 @@ export type TokenMetadata = {
         uri: string;
     } | null;
 };
+export type CreateStreamParams = {
+    configName: string;
+    feePayer?: Address;
+    receiver: Address;
+    sender: Address;
+    streamToken: Address;
+    streamTokenSymbol: string;
+    feeToken: Address;
+    feeTokenSymbol: string;
+    amount: Numeric;
+    automaticWithdrawal: boolean;
+    cancelableByRecipient: boolean;
+    cancelableBySender: boolean;
+    cliffPercentage: Numeric;
+    duration: number;
+    isPausable: boolean;
+    startNow: boolean;
+    startTime: number;
+    autoWithdrawFrequency: number;
+    streamName: string;
+    transferableByRecipient: boolean;
+    transferableBySender: boolean;
+    canTopup: boolean;
+    rateUpdatable: boolean;
+    streamMetadataKeypair?: Keypair;
+};
+export type InitializeStreamConfigParams = {
+    admin?: Address;
+    config: {
+        baseFeePercent: Numeric;
+        frequencies: number[];
+        platformFeePercent: Numeric;
+        withdrawAccount: Address;
+        configName: string;
+        feeTiers: FeeTier[];
+        feeVault: Address;
+    };
+};
+export type FeeTier = {
+    minThreshold: Numeric;
+    maxThreshold: Numeric;
+    feeRateInPercent: Numeric;
+};
+export type UpdateStreamConfigParams = {
+    admin?: Address;
+    config: {
+        baseFeePercent: Numeric;
+        frequencies: number[];
+        platformFeePercent: Numeric;
+        withdrawAccount: Address;
+        configName: string;
+        feeTiers: FeeTier[];
+        feeVault: Address;
+    };
+};
+export type CancelStreamParams = {
+    feePayer?: Address;
+    streamMetadata: Address;
+    user: Address;
+};
+export type PauseResumeStreamParams = {
+    streamMetadata: Address;
+};
+export type WithdrawStreamParams = {
+    streamMetadata: Address;
+    withdrawer?: Address;
+    feePayer?: Address;
+    receiver: Address;
+};
+export type WhiteListTokensParams = {
+    admin: Address;
+    tokens: Address[];
+};
+export type ChangeStreamReceiverParams = {
+    streamMetadata: Address;
+    newRecipient: Address;
+    signer: Address;
+};

package/dist/utils.d.ts

@@ -0,0 +1,4 @@
+import type { FeeTier, Numeric, RpcNetwork } from "./types";
+export declare function getTokenUsdPrice(tokenSymbol: string, network: RpcNetwork): Promise<number>;
+export declare function calculateFeeTokenAmountForStream(streamTokenSymbol: string, streamTokenAmount: Numeric, feeTokenSymbol: string, feeTiers: FeeTier[], network: RpcNetwork): Promise<BigNumber>;
+export declare function getFeeRateForUsdAmount(amount: BigNumber, feeTiers: FeeTier[]): string;

package/dist/utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokenUsdPrice = getTokenUsdPrice;
+exports.calculateFeeTokenAmountForStream = calculateFeeTokenAmountForStream;
+exports.getFeeRateForUsdAmount = getFeeRateForUsdAmount;
+const core_utils_1 = require("@zebec-network/core-utils");
+const constants_1 = require("./constants");
+async function getTokenUsdPrice(tokenSymbol, network) {
+    const url = `${constants_1.SUPERAPP_BACKEND_URL[network]}/tokens/quotes/${encodeURIComponent(`${tokenSymbol}_USD`)}/1?type=EXACT_IN&chainName=SOLANA`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Failed to fetch token price for symbol: ${tokenSymbol}, network: ${network}, status: ${response.status} ${body}`);
+    }
+    const data = await response.json();
+    if (!data || !("exchangeRate" in data)) {
+        console.debug("Unexpected response format when fetching token price:", data);
+        throw new Error(`Invalid response format when fetching token price for symbol: ${tokenSymbol}, network: ${network}`);
+    }
+    return Number(data.exchangeRate);
+}
+async function calculateFeeTokenAmountForStream(streamTokenSymbol, streamTokenAmount, feeTokenSymbol, feeTiers, network) {
+    const oneStreamTokenPriceInUsd = await getTokenUsdPrice(streamTokenSymbol, network);
+    const oneFeeTokenPriceInUsd = await getTokenUsdPrice(feeTokenSymbol, network);
+    if (oneFeeTokenPriceInUsd === 0) {
+        throw new Error(`Fee token price is zero for symbol: ${feeTokenSymbol}, network: ${network}`);
+    }
+    const streamTokenAmountUsdPrice = new BigNumber(streamTokenAmount).times(oneStreamTokenPriceInUsd);
+    const feeRateInBps = getFeeRateForUsdAmount(streamTokenAmountUsdPrice, feeTiers);
+    const feeAmountUsdPrice = streamTokenAmountUsdPrice.times(feeRateInBps).div(10000);
+    const feeTokenAmount = feeAmountUsdPrice.div(oneFeeTokenPriceInUsd);
+    return feeTokenAmount;
+}
+function getFeeRateForUsdAmount(amount, feeTiers) {
+    feeTiers.sort((a, b) => BigNumber(a.minThreshold).comparedTo(BigNumber(b.minThreshold)) ?? 0);
+    const tier = feeTiers.find((tier) => amount.gte(tier.minThreshold) && amount.lt(tier.maxThreshold));
+    if (!tier) {
+        throw new Error(`No fee tier found for amount: ${amount}`);
+    }
+    return (0, core_utils_1.percentToBps)(tier.feeRateInPercent);
+}

package/package.json

@@ -40,5 +40,5 @@
     "test:single": "ts-mocha -p ./tsconfig.json -t 1000000000"
   },
   "types": "dist/index.d.ts",
-  "version": "2.1.0"
+  "version": "3.0.0-dev.2"
 }