@zebec-network/zebec-stream-sdk 1.0.0

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const STREAM_NAME_BUFFER_SIZE = 128;

package/dist/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STREAM_NAME_BUFFER_SIZE = void 0;
+exports.STREAM_NAME_BUFFER_SIZE = 128;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./artifacts";
+export * from "./pda";
+export * from "./providers";
+export * from "./service";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./artifacts"), exports);
+__exportStar(require("./pda"), exports);
+__exportStar(require("./providers"), exports);
+__exportStar(require("./service"), exports);
+__exportStar(require("./types"), exports);

package/dist/pda.d.ts

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

package/dist/pda.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveStreamConfigPda = deriveStreamConfigPda;
+exports.deriveStreamVaultPda = deriveStreamVaultPda;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const SEEDS = {
+    STREAM_CONFIG: [99, 111, 110, 102, 105, 103],
+};
+function deriveStreamConfigPda(programId) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from(SEEDS.STREAM_CONFIG)], (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/providers.d.ts

@@ -0,0 +1,17 @@
+import { Address, AnchorProvider } from "@coral-xyz/anchor";
+import { ConfirmOptions, Connection, PublicKey, Transaction, VersionedTransaction } from "@solana/web3.js";
+export declare class ReadonlyProvider {
+    readonly connection: Connection;
+    readonly walletAddress?: PublicKey;
+    constructor(connection: Connection, walletAddress?: Address);
+}
+export declare function createReadonlyProvider(connection: Connection, walletAddress?: Address): ReadonlyProvider;
+/**
+ * Wallet interface used by Anchor Framework
+ */
+export interface AnchorWallet {
+    signTransaction: <T extends Transaction | VersionedTransaction>(tx: T) => Promise<T>;
+    signAllTransactions: <T extends Transaction | VersionedTransaction>(txs: T[]) => Promise<T[]>;
+    publicKey: PublicKey;
+}
+export declare function createAnchorProvider(connection: Connection, wallet: AnchorWallet, options?: ConfirmOptions): AnchorProvider;

package/dist/providers.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReadonlyProvider = void 0;
+exports.createReadonlyProvider = createReadonlyProvider;
+exports.createAnchorProvider = createAnchorProvider;
+const anchor_1 = require("@coral-xyz/anchor");
+class ReadonlyProvider {
+    connection;
+    walletAddress;
+    constructor(connection, walletAddress) {
+        this.connection = connection;
+        this.walletAddress = walletAddress ? (0, anchor_1.translateAddress)(walletAddress) : undefined;
+    }
+}
+exports.ReadonlyProvider = ReadonlyProvider;
+function createReadonlyProvider(connection, walletAddress) {
+    return new ReadonlyProvider(connection, walletAddress);
+}
+function createAnchorProvider(connection, wallet, options) {
+    return new anchor_1.AnchorProvider(connection, wallet, {
+        ...anchor_1.AnchorProvider.defaultOptions(),
+        ...options,
+    });
+}

package/dist/service.d.ts

@@ -0,0 +1,108 @@
+import { Address, BN, Program, Provider } from "@coral-xyz/anchor";
+import { Commitment, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { TransactionPayload } from "@zebec-network/solana-common";
+import { ZebecStreamIdl } from "./artifacts";
+import { Numeric, StreamConfigInfo, StreamMetadataInfo } from "./types";
+export declare class ZebecStreamService {
+    readonly provider: Provider;
+    readonly network: "mainnet-beta" | "devnet";
+    readonly program: Program<ZebecStreamIdl>;
+    constructor(provider: Provider, network: "mainnet-beta" | "devnet", program: Program<ZebecStreamIdl>);
+    static create(provider: Provider, network: "mainnet-beta" | "devnet"): ZebecStreamService;
+    private _createPayload;
+    get connection(): import("@solana/web3.js").Connection;
+    get programId(): PublicKey;
+    getInitializeConfigInstruction(admin: PublicKey, config: {
+        baseFee: BN;
+        frequencies: BN[];
+        platformFee: BN;
+        withdrawAccount: PublicKey;
+    }): Promise<TransactionInstruction>;
+    getCreateStreamInstruction(feePayer: PublicKey, receiver: PublicKey, senderAta: PublicKey, streamToken: PublicKey, withdrawAccount: PublicKey, sender: PublicKey, streamMetadata: PublicKey, streamData: {
+        amount: BN;
+        automaticWithdrawal: boolean;
+        cancelableByRecipient: boolean;
+        cancelableBySender: boolean;
+        canTopup: boolean;
+        cliffPercentage: BN;
+        duration: BN;
+        isPausable: boolean;
+        rateUpdatable: boolean;
+        startNow: boolean;
+        startTime: BN;
+        streamFrequency: BN;
+        streamName: Uint8Array | Buffer;
+        transferableByRecipient: boolean;
+        transferableBySender: boolean;
+        numberOfWithdrawls: BN;
+    }): Promise<TransactionInstruction>;
+    getPauseResumeStreamInstruction(streamMetadata: PublicKey, user: PublicKey): Promise<TransactionInstruction>;
+    getCancelStreamInstruction(feePayer: PublicKey, otherParty: PublicKey, otherPartyAta: PublicKey, signer: PublicKey, signerAta: PublicKey, streamMetadata: PublicKey, streamToken: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey): Promise<TransactionInstruction>;
+    getWithdrawStreamInstruction(receiver: PublicKey, receiverAta: PublicKey, streamMetadata: PublicKey, streamToken: PublicKey, streamVault: PublicKey, streamVaultAta: PublicKey, withdrawer: PublicKey): Promise<TransactionInstruction>;
+    getWhitelistTokensInstruction(admin: PublicKey, tokens: PublicKey[]): Promise<TransactionInstruction>;
+    getChangeStreamReceiverInstruction(streamMetadata: PublicKey, newRecipient: PublicKey, signer: PublicKey): Promise<TransactionInstruction>;
+    initializeConfig(params: InitializeConfigParams): Promise<TransactionPayload>;
+    createStream(params: CreateStreamParams): Promise<TransactionPayload>;
+    cancelStream(params: CancelStreamParams): Promise<TransactionPayload>;
+    pauseResumeStream(params: {
+        streamMetadata: Address;
+    }): Promise<TransactionPayload>;
+    withdrawStream(params: WithdrawStreamParams): Promise<TransactionPayload>;
+    whiteListTokens(params: WhiteListTokensParams): Promise<TransactionPayload>;
+    changeStreamReceiver(params: ChangeStreamReceiverParams): Promise<TransactionPayload>;
+    getStreamConfigInfo(commitment?: Commitment): Promise<StreamConfigInfo>;
+    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;
+    streamFrequency: number;
+    streamName: string;
+    transferableByRecipient: boolean;
+    transferableBySender: boolean;
+    canTopup: boolean;
+    rateUpdatable: boolean;
+    streamMetadataKeypair?: Keypair;
+};
+export type InitializeConfigParams = {
+    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;
+    receiver: Address;
+};
+export type WhiteListTokensParams = {
+    admin: Address;
+    tokens: Address[];
+};
+export type ChangeStreamReceiverParams = {
+    streamMetadata: Address;
+    newRecipient: Address;
+    signer: Address;
+};

package/dist/service.js

@@ -0,0 +1,337 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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 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 artifacts_1 = require("./artifacts");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+class ZebecStreamService {
+    provider;
+    network;
+    program;
+    constructor(provider, network, program) {
+        this.provider = provider;
+        this.network = network;
+        this.program = program;
+    }
+    static create(provider, network) {
+        const connection = provider.connection;
+        const rpcEndpoint = connection.rpcEndpoint;
+        const connNetwork = rpcEndpoint.includes("devnet")
+            ? "devnet"
+            : rpcEndpoint.includes("testnet")
+                ? "testnet"
+                : "mainnet-beta";
+        if (connNetwork === "testnet") {
+            throw new Error("InvalidOperation: Testnet is not supported. Please use connection with devnet or mainnet-beta network.");
+        }
+        if (network !== connNetwork) {
+            throw new Error(`InvalidOperation: Network mismatch. network and connection network should be same. network: ${network}, connection: ${connNetwork}`);
+        }
+        const program = new anchor_1.Program(artifacts_1.ZEBEC_STREAM_IDL, provider);
+        return new ZebecStreamService(provider, network, program);
+    }
+    async _createPayload(payerKey, instructions, signers, addressLookupTableAccounts) {
+        const errorMap = new Map();
+        this.program.idl.errors.forEach((error) => errorMap.set(error.code, error.msg));
+        const provider = this.provider;
+        let signTransaction;
+        if (provider instanceof anchor_1.AnchorProvider) {
+            signTransaction = async (tx) => {
+                return provider.wallet.signTransaction(tx);
+            };
+        }
+        return new solana_common_1.TransactionPayload(this.connection, errorMap, instructions, payerKey, signers, addressLookupTableAccounts, signTransaction);
+    }
+    get connection() {
+        return this.provider.connection;
+    }
+    get programId() {
+        return this.program.programId;
+    }
+    async getInitializeConfigInstruction(admin, config) {
+        return this.program.methods
+            .initializeConfig({
+            baseFee: config.baseFee,
+            frequencies: config.frequencies,
+            platformFee: config.platformFee,
+            withdrawAccount: config.withdrawAccount,
+        })
+            .accounts({
+            admin,
+        })
+            .instruction();
+    }
+    getCreateStreamInstruction(feePayer, receiver, senderAta, streamToken, withdrawAccount, sender, streamMetadata, streamData) {
+        (0, assert_1.default)(streamData.streamName.length === constants_1.STREAM_NAME_BUFFER_SIZE, `Stream name buffer must be of size ${constants_1.STREAM_NAME_BUFFER_SIZE}`);
+        return this.program.methods
+            .createStream({
+            amount: streamData.amount,
+            automaticWithdrawal: Number(streamData.automaticWithdrawal),
+            cancelableByRecipient: Number(streamData.cancelableByRecipient),
+            cancelableBySender: Number(streamData.cancelableBySender),
+            canTopup: Number(streamData.canTopup),
+            cliffPercentage: streamData.cliffPercentage,
+            duration: streamData.duration,
+            isPausable: Number(streamData.isPausable),
+            rateUpdatable: Number(streamData.rateUpdatable),
+            receiver,
+            sender,
+            startNow: Number(streamData.startNow),
+            startTime: streamData.startTime,
+            streamFrequency: streamData.streamFrequency,
+            streamName: Array.from(streamData.streamName),
+            transferableByRecipient: Number(streamData.transferableByRecipient),
+            transferableBySender: Number(streamData.transferableBySender),
+        })
+            .accountsPartial({
+            feePayer,
+            receiver,
+            senderAta,
+            streamToken,
+            withdrawAccount,
+            sender,
+            streamMetadata,
+        })
+            .instruction();
+    }
+    getPauseResumeStreamInstruction(streamMetadata, user) {
+        return this.program.methods
+            .pauseResumeStream()
+            .accounts({
+            streamMetadata,
+            user,
+        })
+            .instruction();
+    }
+    getCancelStreamInstruction(feePayer, otherParty, otherPartyAta, signer, signerAta, streamMetadata, streamToken, streamVault, streamVaultAta) {
+        return this.program.methods
+            .cancelStream()
+            .accountsPartial({
+            feePayer,
+            otherParty,
+            otherPartyAta,
+            signer,
+            signerAta,
+            streamMetadata,
+            streamToken,
+            streamVault,
+            streamVaultAta,
+        })
+            .instruction();
+    }
+    getWithdrawStreamInstruction(receiver, receiverAta, streamMetadata, streamToken, streamVault, streamVaultAta, withdrawer) {
+        return this.program.methods
+            .withdrawStream()
+            .accountsPartial({
+            streamMetadata,
+            streamToken,
+            streamVault,
+            streamVaultAta,
+            receiver,
+            receiverAta,
+            withdrawer,
+        })
+            .instruction();
+    }
+    async getWhitelistTokensInstruction(admin, tokens) {
+        return this.program.methods
+            .whitelistTokens({
+            tokens,
+        })
+            .accounts({
+            admin,
+        })
+            .instruction();
+    }
+    async getChangeStreamReceiverInstruction(streamMetadata, newRecipient, signer) {
+        return this.program.methods
+            .changeRecipient()
+            .accounts({
+            newRecipient,
+            stream: streamMetadata,
+            signer,
+        })
+            .instruction();
+    }
+    async initializeConfig(params) {
+        const admin = params.admin ? (0, anchor_1.translateAddress)(params.admin) : this.provider.publicKey;
+        if (!admin) {
+            throw new Error("Either provide admin or create provider with public key");
+        }
+        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.getInitializeConfigInstruction(admin, {
+            baseFee,
+            frequencies,
+            platformFee,
+            withdrawAccount,
+        });
+        return this._createPayload(admin, [ix]);
+    }
+    async createStream(params) {
+        const receiver = (0, anchor_1.translateAddress)(params.receiver);
+        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 streamConfigAccount = await this.program.account.streamConfig.fetch(streamConfig);
+        const withdrawer = streamConfigAccount.withdrawAccount;
+        const streamFrequencies = new Set(Array.from(streamConfigAccount.frequencies.map((f) => f.toNumber())));
+        if (!streamFrequencies.has(params.streamFrequency)) {
+            throw new Error("Invalid stream frequency");
+        }
+        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 cliffPercentage = new anchor_1.BN((0, core_utils_1.percentToBps)(params.cliffPercentage));
+        const streamNameBuffer = Buffer.alloc(constants_1.STREAM_NAME_BUFFER_SIZE);
+        streamNameBuffer.fill(anchor_1.utils.bytes.utf8.encode(params.streamName), 0);
+        const ix = await this.getCreateStreamInstruction(feePayer, receiver, senderAta, streamToken, withdrawer, sender, streamMetadataKeypair.publicKey, {
+            amount,
+            automaticWithdrawal: params.automaticWithdrawal,
+            cancelableByRecipient: params.cancelableByRecipient,
+            cancelableBySender: params.cancelableBySender,
+            canTopup: params.canTopup,
+            cliffPercentage,
+            duration: new anchor_1.BN(params.duration),
+            isPausable: params.isPausable,
+            numberOfWithdrawls: new anchor_1.BN(params.duration / params.streamFrequency),
+            rateUpdatable: params.rateUpdatable,
+            startNow: params.startNow,
+            startTime: new anchor_1.BN(params.startTime),
+            streamFrequency: new anchor_1.BN(params.streamFrequency),
+            streamName: streamNameBuffer,
+            transferableByRecipient: params.transferableByRecipient,
+            transferableBySender: params.transferableBySender,
+        });
+        return this._createPayload(feePayer, [ix], [streamMetadataKeypair]);
+    }
+    async cancelStream(params) {
+        const user = (0, anchor_1.translateAddress)(params.user);
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.program.account.paymentStream.fetch(streamMetadata);
+        const streamToken = streamMetadataAccount.financials.streamToken;
+        const streamer = streamMetadataAccount.parties.sender;
+        const receiver = streamMetadataAccount.parties.receiver;
+        let otherParty;
+        if (user.equals(streamer)) {
+            otherParty = receiver;
+        }
+        else if (user.equals(receiver)) {
+            otherParty = streamer;
+        }
+        else {
+            throw new Error("User must be either streamer or receiver");
+        }
+        const feePayer = params.feePayer ? (0, anchor_1.translateAddress)(params.feePayer) : user;
+        const userAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, user, true);
+        const otherPartyAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, otherParty, true);
+        const [streamVault] = (0, pda_1.deriveStreamVaultPda)(streamMetadata, this.programId);
+        const streamVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, streamVault, true);
+        const ix = await this.getCancelStreamInstruction(feePayer, otherParty, otherPartyAta, user, userAta, streamMetadata, streamToken, streamVault, streamVaultAta);
+        return this._createPayload(feePayer, [ix]);
+    }
+    async pauseResumeStream(params) {
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.program.account.paymentStream.fetch(streamMetadata);
+        const user = streamMetadataAccount.parties.sender;
+        const ix = await this.getPauseResumeStreamInstruction(streamMetadata, user);
+        return this._createPayload(user, [ix]);
+    }
+    async withdrawStream(params) {
+        const receiver = (0, anchor_1.translateAddress)(params.receiver);
+        const withdrawer = params.withdrawer ? (0, anchor_1.translateAddress)(params.withdrawer) : receiver;
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const streamMetadataAccount = await this.program.account.paymentStream.fetch(streamMetadata);
+        const streamToken = streamMetadataAccount.financials.streamToken;
+        const receiverAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, receiver, true);
+        const [streamVault] = (0, pda_1.deriveStreamVaultPda)(streamMetadata, this.programId);
+        const streamVaultAta = (0, solana_common_1.getAssociatedTokenAddressSync)(streamToken, streamVault, true);
+        const ix = await this.getWithdrawStreamInstruction(receiver, receiverAta, streamMetadata, streamToken, streamVault, streamVaultAta, withdrawer);
+        return this._createPayload(withdrawer, [ix]);
+    }
+    async whiteListTokens(params) {
+        const admin = (0, anchor_1.translateAddress)(params.admin);
+        const tokens = params.tokens.map((token) => (0, anchor_1.translateAddress)(token));
+        const ix = await this.getWhitelistTokensInstruction(admin, tokens);
+        return this._createPayload(admin, [ix]);
+    }
+    async changeStreamReceiver(params) {
+        const streamMetadata = (0, anchor_1.translateAddress)(params.streamMetadata);
+        const newRecipient = (0, anchor_1.translateAddress)(params.newRecipient);
+        const signer = (0, anchor_1.translateAddress)(params.signer);
+        const ix = await this.getChangeStreamReceiverInstruction(streamMetadata, newRecipient, signer);
+        return this._createPayload(signer, [ix]);
+    }
+    async getStreamConfigInfo(commitment) {
+        const [config] = (0, pda_1.deriveStreamConfigPda)(this.programId);
+        const configInfo = await this.program.account.streamConfig.fetch(config, commitment ?? this.connection.commitment);
+        return {
+            admin: configInfo.admin,
+            withdrawerAccount: configInfo.withdrawAccount,
+            whitelistedTokens: configInfo.whitelistedTokens,
+            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()),
+        };
+    }
+    async getStreamMetadataInfo(streamMetadata, commitment) {
+        const metadataInfo = await this.program.account.paymentStream.fetch((0, anchor_1.translateAddress)(streamMetadata), commitment ?? this.connection.commitment);
+        const streamToken = metadataInfo.financials.streamToken;
+        const streamTokenDecimals = await (0, solana_common_1.getMintDecimals)(this.connection, streamToken);
+        const unitsPerStreamToken = solana_common_1.TEN_BIGNUM.pow(streamTokenDecimals);
+        const depositedAmount = (0, bignumber_js_1.BigNumber)(metadataInfo.financials.depositedAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const withdrawnAmount = (0, bignumber_js_1.BigNumber)(metadataInfo.financials.withdrawnAmount.toString())
+            .div(unitsPerStreamToken)
+            .toFixed();
+        const cliffPercentage = Number((0, core_utils_1.bpsToPercent)(metadataInfo.financials.cliffPercentage.toNumber()));
+        return {
+            parties: {
+                sender: metadataInfo.parties.sender,
+                receiver: metadataInfo.parties.receiver,
+            },
+            financials: {
+                streamToken,
+                cliffPercentage,
+                depositedAmount,
+                withdrawnAmount,
+            },
+            schedule: {
+                startTime: metadataInfo.schedule.startTime.toNumber(),
+                endTime: metadataInfo.schedule.endTime.toNumber(),
+                lastWithdrawTime: metadataInfo.schedule.lastWithdrawTime.toNumber(),
+                frequency: metadataInfo.schedule.frequency.toNumber(),
+                duration: metadataInfo.schedule.duration.toNumber(),
+                pausedTimestamp: metadataInfo.schedule.pausedTimestamp.toNumber(),
+                pausedInterval: metadataInfo.schedule.pausedInterval.toNumber(),
+                canceledTimestamp: metadataInfo.schedule.canceledTimestamp.toNumber(),
+            },
+            permissions: {
+                cancelableBySender: Boolean(metadataInfo.permissions.cancelableBySender),
+                cancelableByRecipient: Boolean(metadataInfo.permissions.cancelableBySender),
+                automaticWithdrawal: Boolean(metadataInfo.permissions.automaticWithdrawal),
+                transferableBySender: Boolean(metadataInfo.permissions.transferableBySender),
+                transferableByRecipient: Boolean(metadataInfo.permissions.transferableByRecipient),
+                canTopup: Boolean(metadataInfo.permissions.canTopup),
+                isPausable: Boolean(metadataInfo.permissions.isPausable),
+                rateUpdatable: Boolean(metadataInfo.permissions.rateUpdatable),
+            },
+            streamName: anchor_1.utils.bytes.utf8.decode(Uint8Array.from(metadataInfo.streamName)),
+        };
+    }
+}
+exports.ZebecStreamService = ZebecStreamService;

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+import { PublicKey } from "@solana/web3.js";
+export type Numeric = string | number;
+export type StreamConfigInfo = {
+    admin: PublicKey;
+    withdrawerAccount: PublicKey;
+    whitelistedTokens: PublicKey[];
+    platformFee: number;
+    baseFee: number;
+    frequencies: number[];
+};
+export type StreamMetadataInfo = {
+    parties: {
+        sender: PublicKey;
+        receiver: PublicKey;
+    };
+    financials: {
+        streamToken: PublicKey;
+        cliffPercentage: number;
+        depositedAmount: string;
+        withdrawnAmount: string;
+    };
+    schedule: {
+        startTime: number;
+        endTime: number;
+        lastWithdrawTime: number;
+        frequency: number;
+        duration: number;
+        pausedTimestamp: number;
+        pausedInterval: number;
+        canceledTimestamp: number;
+    };
+    permissions: {
+        cancelableBySender: boolean;
+        cancelableByRecipient: boolean;
+        automaticWithdrawal: boolean;
+        transferableBySender: boolean;
+        transferableByRecipient: boolean;
+        canTopup: boolean;
+        isPausable: boolean;
+        rateUpdatable: boolean;
+    };
+    streamName: string;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@zebec-network/zebec-stream-sdk",
+  "version": "1.0.0",
+  "description": "This is an SDK for interacting with ZEBEC Stream Program in solana",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "author": "Ashish Sapkota",
+  "license": "MIT",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "npm run clean && tsc",
+    "clean": "rimraf ./dist",
+    "format": "prettier --write .",
+    "start": "ts-node src/index.ts",
+    "test": "ts-mocha -p ./tsconfig.json -t 1000000000 test/**/*.spec.ts",
+    "test:single": "ts-mocha -p ./tsconfig.json -t 1000000000"
+  },
+  "devDependencies": {
+    "@solana/spl-token": "^0.4.13",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.0.15",
+    "dotenv": "^17.2.0",
+    "mocha": "^11.7.1",
+    "prettier": "^3.6.2",
+    "rimraf": "^6.0.1",
+    "ts-mocha": "^11.1.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.8.3"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.31.1",
+    "@solana/web3.js": "^1.98.2",
+    "@types/bn.js": "^5.2.0",
+    "@zebec-network/core-utils": "^1.0.4",
+    "@zebec-network/solana-common": "^1.5.1",
+    "bignumber.js": "^9.3.1"
+  }
+}