@usepiper/sdk 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Piper-Org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,368 @@
+# 🧰 Piper TypeScript SDK
+
+The official **TypeScript SDK** for the [Piper Protocol](https://github.com/piper-protocol) — a programmable payment streaming primitive on Sui.
+
+`@usepiper/sdk` provides a clean, typed interface for building **Programmable Transaction Blocks (PTBs)** that interact with the Piper Move contracts. No need to manually construct Move calls or juggle `Coin` objects — the SDK handles the entire flow, enabling you to integrate per‑second streaming, DCA, and pay‑per‑use billing into your dApp with just a few lines of code.
+
+---
+
+## 📦 Installation
+
+```bash
+npm install @usepiper/sdk @mysten/sui
+```
+
+> **Note:** The SDK depends on `@mysten/sui` (the standard Sui TypeScript library) for `Transaction`, `TransactionArgument`, and other core types.
+
+---
+
+## 🚀 Quick Start
+
+### 1. Configure the Piper Package ID
+
+Before using any function, set the package ID of the deployed Piper Move contract. You only need to do this **once** at application startup. The SDK ships with the testnet package ID as a default.
+
+```typescript
+import { Piper } from '@usepiper/sdk';
+
+// Optional — testnet is pre-configured
+Piper.setPackageId('0xYOUR_MAINNET_PACKAGE_ID');
+```
+
+### 2. Import and Use in a Transaction
+
+All SDK functions operate on a `Transaction` object from `@mysten/sui`. You build up a transaction, add Piper commands, and then sign & execute it with your wallet.
+
+```typescript
+import { Transaction } from '@mysten/sui/transactions';
+import { Piper } from '@usepiper/sdk';
+
+const tx = new Transaction();
+
+// Create a continuous stream
+const stream = Piper.createContinuousStream(tx, {
+    coin: myUsdcCoinObject,
+    coinType: '0x<usdc_package>::usdc::USDC',
+    flowRate: 38, // 38 microunits/second → ~100 USDC/month
+    recipient: '0xRecipientAddress',
+});
+
+// The returned stream must be transferred or shared
+tx.transferObjects([stream], tx.pure.address(senderAddress));
+
+// Sign and execute via wallet
+const result = await client.signAndExecuteTransaction({
+    signer: keypair,
+    transaction: tx,
+});
+```
+
+All functions are **pure** — they don't submit transactions or manage state. They simply append Move calls to the transaction you provide. The SDK automatically injects the Sui `Clock` object where required.
+
+---
+
+## 📘 API Reference
+
+### `Piper.setPackageId(packageId: string)`
+Sets the Move package ID for all subsequent calls. Call this early in your app. Defaults to the Piper testnet package.
+
+---
+
+### `Piper.createContinuousStream(tx, config): TransactionArgument`
+Creates a new continuous (time‑based) stream.
+
+**Parameters:**
+- `tx` – The `Transaction` to add the command to.
+- `config`:
+  - `coin` (`TransactionArgument | string`): The coin object (or its ID) to deposit.
+  - `coinType` (`string`): Full coin type, e.g., `'0x2::sui::SUI'`.
+  - `flowRate` (`number | bigint`): Tokens (in smallest units) to stream **per second**.
+  - `recipient` (`string`): Sui address of the primary receiver.
+
+**Returns:** A `TransactionArgument` representing the created `Stream<T>` object. You must transfer or share this object in the same transaction.
+
+**Example:**
+```typescript
+const stream = Piper.createContinuousStream(tx, {
+    coin: '0xMyUSDC',
+    coinType: '0x<pkg>::usdc::USDC',
+    flowRate: 1_000_000,  // 1 USDC per second (if USDC has 6 decimals)
+    recipient: '0xBossWallet',
+});
+tx.transferObjects([stream], tx.pure.address(senderAddress));
+```
+
+---
+
+### `Piper.createOnDemandStream(tx, config): TransactionArgument`
+Creates a pay‑per‑use stream (flow rate = 0). Only the designated `authorizedSpender` can call `pay`.
+
+**Parameters:**
+- `config`:
+  - `coin` (`TransactionArgument | string`): The deposited budget.
+  - `coinType` (`string`): Full coin type.
+  - `recipient` (`string`): Address that receives payments.
+  - `authorizedSpender` (`string`): The Sui address allowed to call `pay`.
+
+**Returns:** A `TransactionArgument` representing the created `Stream<T>` object.
+
+**Example:**
+```typescript
+const stream = Piper.createOnDemandStream(tx, {
+    coin: '0xPrepaidUSDC',
+    coinType: '0x<pkg>::usdc::USDC',
+    recipient: '0xServiceWallet',
+    authorizedSpender: '0xBackendHotWallet',
+});
+tx.transferObjects([stream], tx.pure.address(senderAddress));
+```
+
+---
+
+### `Piper.tick(tx, config): void`
+Triggers a payment tick on a continuous stream. This function is **permissionless** — anyone can call it. The stream calculates the owed amount since `last_tick_at`, deducts it, applies splits, and transfers funds to all recipients on-chain.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The ID of the stream to tick.
+  - `coinType` (`string`): The token type of the stream.
+
+**Note:** Unlike the creation functions, `tick` does not return a value. The Move contract handles all coin transfers internally — funds are sent directly to the primary recipient and any split recipients on-chain.
+
+**Example:**
+```typescript
+Piper.tick(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+});
+```
+
+---
+
+### `Piper.pay(tx, config): void`
+Performs an on‑demand payment from a pay‑per‑use stream. **Must be called by the `authorizedSpender`** — the transaction must be signed by the spender's key.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream ID.
+  - `coinType` (`string`): The token type of the stream.
+  - `amount` (`number | bigint`): How many tokens (in smallest units) to deduct.
+
+**Example:**
+```typescript
+// Inside your backend service (the authorized spender)
+const tx = new Transaction();
+Piper.pay(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+    amount: 500_000,
+});
+const result = await client.signAndExecuteTransaction({
+    signer: backendKeypair,
+    transaction: tx,
+});
+```
+
+> ⚠️ **Security:** This function does **not** send the transaction. You must sign and submit it with the spender's key. The SDK simply adds the Move call; the authorization check happens on‑chain based on `ctx.sender()`.
+
+---
+
+### `Piper.revoke(tx, config): TransactionArgument`
+Stops a stream and returns all remaining balance as a `Coin<T>`. Only the creator can call this (enforced on‑chain). The returned coin must be transferred or consumed in the same transaction.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream to revoke.
+  - `coinType` (`string`): The token type of the stream.
+
+**Returns:** A `TransactionArgument` representing the remaining `Coin<T>`.
+
+**Example:**
+```typescript
+const remainingCoin = Piper.revoke(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+});
+// Transfer the remaining funds back to yourself
+tx.transferObjects([remainingCoin], tx.pure.address(myAddress));
+```
+
+---
+
+### `Piper.topUp(tx, config): void`
+Adds additional funds to an existing stream. Anyone can top up a stream.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream to top up.
+  - `coinType` (`string`): The token type of the stream.
+  - `coin` (`TransactionArgument | string`): The coin object (or its ID) to deposit.
+
+**Example:**
+```typescript
+Piper.topUp(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+    coin: '0xAdditionalUSDC',
+});
+```
+
+---
+
+### `Piper.addSplit(tx, config): void`
+Adds a percentage-based split recipient to a stream. Only the stream creator can manage splits (enforced on-chain). Total split percentages cannot exceed 100%.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream to configure.
+  - `coinType` (`string`): The token type of the stream.
+  - `recipient` (`string`): The Sui address that will receive this split.
+  - `percent` (`number`): Percentage share (1–100).
+
+**Example:**
+```typescript
+Piper.addSplit(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+    recipient: '0xTaxWallet',
+    percent: 20,
+});
+```
+
+---
+
+### `Piper.removeSplit(tx, config): void`
+Removes a split by index. Only the stream creator can manage splits.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream to modify.
+  - `coinType` (`string`): The token type of the stream.
+  - `index` (`number`): The index of the split to remove.
+
+**Example:**
+```typescript
+Piper.removeSplit(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+    index: 0,
+});
+```
+
+---
+
+### `Piper.destroyEmpty(tx, config): void`
+Destroys an inactive stream with zero balance. This deletes the `Stream` object from on-chain storage.
+
+**Parameters:**
+- `config`:
+  - `streamId` (`string | TransactionArgument`): The stream to destroy.
+  - `coinType` (`string`): The token type of the stream.
+
+**Example:**
+```typescript
+Piper.destroyEmpty(tx, {
+    streamId: '0xMyStreamId',
+    coinType: '0x<pkg>::usdc::USDC',
+});
+```
+
+---
+
+### Utility Functions
+
+#### `extractStreamId(result): string`
+Extracts the created `Stream` object ID from the transaction result after calling `createContinuousStream` or `createOnDemandStream`.
+
+```typescript
+import { extractStreamId } from '@usepiper/sdk';
+
+const result = await client.signAndExecuteTransaction({ signer, transaction: tx });
+const streamId = extractStreamId(result);
+```
+
+#### `calculateFlowRate(totalAmount, durationSeconds): bigint`
+Computes the flow rate needed to stream a total amount evenly over a duration (in seconds).
+
+```typescript
+import { calculateFlowRate } from '@usepiper/sdk';
+
+const flowRate = calculateFlowRate(100_000_000n, 30 * 24 * 3600); // 100 USDC over 30 days
+```
+
+---
+
+## 🧩 Integration with Sui dApp Kit
+
+The SDK works seamlessly with `@mysten/dapp-kit`:
+
+```tsx
+import { useSignAndExecuteTransaction } from '@mysten/dapp-kit';
+import { Piper, extractStreamId } from '@usepiper/sdk';
+
+function MyComponent() {
+    const { mutate: signAndExecute } = useSignAndExecuteTransaction();
+
+    const handleCreateStream = async () => {
+        const tx = new Transaction();
+        const stream = Piper.createContinuousStream(tx, {
+            coin: myCoinId,
+            coinType: '0x2::sui::SUI',
+            flowRate: 100,
+            recipient: recipientAddress,
+        });
+        tx.transferObjects([stream], tx.pure.address(myAddress));
+
+        signAndExecute({ transaction: tx }, {
+            onSuccess: (result) => {
+                const streamId = extractStreamId(result);
+                console.log('Stream created:', streamId);
+            },
+        });
+    };
+
+    return <button onClick={handleCreateStream}>Start Streaming</button>;
+}
+```
+
+---
+
+## 🔐 Security Model
+
+- **No key custody:** The SDK never asks for or stores private keys. Transactions are signed by the wallet (or your backend key).
+- **All checks on‑chain:** Authorization (creator vs. spender) is enforced by the Move contract.
+- **The SDK only constructs PTBs.** You remain in full control of signing and execution.
+
+---
+
+## 🧪 Testing & Development
+
+Clone the repo and run:
+
+```bash
+npm install
+npm run test
+```
+
+The tests are written with `vitest` and verify that the SDK constructs correct Move calls.
+
+To contribute, see `CONTRIBUTING.md`.
+
+---
+
+## 📚 More Resources
+
+- **Piper Protocol Docs** – [piper-docs](https://github.com/piper-protocol/piper-docs)
+- **Move Contracts** – [piper-move](https://github.com/piper-protocol/piper-move)
+- **Frontend PWA** – [piper-app](https://github.com/piper-protocol/piper-app)
+- **Indexer** – [piper-indexer](https://github.com/piper-protocol/piper-indexer)
+
+---
+
+## 📄 License
+
+MIT
+
+---
+
+**Piper SDK** — *Plug programmability into your payments.*

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Piper SDK Constants
+ *
+ * Package IDs, module names, and system object IDs used across the SDK.
+ */
+/** Piper testnet package ID (from Published.toml) */
+export declare const PIPER_TESTNET_PACKAGE_ID = "0x8f33eecb14d7990f19374499622f8ac4f9d493ace3368209f3969ccc149d3da7";
+/** Sui system Clock object ID */
+export declare const CLOCK_OBJECT_ID = "0x6";
+/** Piper Move module name for stream operations */
+export declare const STREAM_MODULE = "stream";
+/** Piper Move package name */
+export declare const PACKAGE_NAME = "piper";
+/**
+ * Fully qualified Move function target.
+ * Format: `{packageId}::{module}::{function}`
+ */
+export declare function target(packageId: string, fn: string, module?: string): `${string}::${string}::${string}`;
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,qDAAqD;AACrD,eAAO,MAAM,wBAAwB,uEACiC,CAAC;AAEvE,iCAAiC;AACjC,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,mDAAmD;AACnD,eAAO,MAAM,aAAa,WAAW,CAAC;AAEtC,8BAA8B;AAC9B,eAAO,MAAM,YAAY,UAAU,CAAC;AAEpC;;;GAGG;AACH,wBAAgB,MAAM,CACpB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,MAAM,EACV,MAAM,GAAE,MAAsB,GAC7B,GAAG,MAAM,KAAK,MAAM,KAAK,MAAM,EAAE,CAEnC"}

package/dist/constants.js

@@ -0,0 +1,21 @@
+/**
+ * Piper SDK Constants
+ *
+ * Package IDs, module names, and system object IDs used across the SDK.
+ */
+/** Piper testnet package ID (from Published.toml) */
+export const PIPER_TESTNET_PACKAGE_ID = '0x8f33eecb14d7990f19374499622f8ac4f9d493ace3368209f3969ccc149d3da7';
+/** Sui system Clock object ID */
+export const CLOCK_OBJECT_ID = '0x6';
+/** Piper Move module name for stream operations */
+export const STREAM_MODULE = 'stream';
+/** Piper Move package name */
+export const PACKAGE_NAME = 'piper';
+/**
+ * Fully qualified Move function target.
+ * Format: `{packageId}::{module}::{function}`
+ */
+export function target(packageId, fn, module = STREAM_MODULE) {
+    return `${packageId}::${module}::${fn}`;
+}
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,qDAAqD;AACrD,MAAM,CAAC,MAAM,wBAAwB,GACnC,oEAAoE,CAAC;AAEvE,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAC;AAErC,mDAAmD;AACnD,MAAM,CAAC,MAAM,aAAa,GAAG,QAAQ,CAAC;AAEtC,8BAA8B;AAC9B,MAAM,CAAC,MAAM,YAAY,GAAG,OAAO,CAAC;AAEpC;;;GAGG;AACH,MAAM,UAAU,MAAM,CACpB,SAAiB,EACjB,EAAU,EACV,SAAiB,aAAa;IAE9B,OAAO,GAAG,SAAS,KAAK,MAAM,KAAK,EAAE,EAAE,CAAC;AAC1C,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @usepiper/sdk — Piper Protocol TypeScript SDK
+ *
+ * A clean, typed interface for building Programmable Transaction Blocks (PTBs)
+ * that interact with the Piper Move contracts on Sui.
+ *
+ * @example
+ * ```typescript
+ * import { Transaction } from '@mysten/sui/transactions';
+ * import { Piper, extractStreamId } from '@usepiper/sdk';
+ *
+ * const tx = new Transaction();
+ * const stream = Piper.createContinuousStream(tx, {
+ *   coin: myCoinId,
+ *   coinType: '0x2::sui::SUI',
+ *   flowRate: 100,
+ *   recipient: '0xRecipient',
+ * });
+ * tx.transferObjects([stream], tx.pure.address(myAddress));
+ * ```
+ *
+ * @packageDocumentation
+ */
+export { Piper } from './piper.js';
+export { extractStreamId, calculateFlowRate, parsePiperEvents, } from './utils.js';
+export { PIPER_TESTNET_PACKAGE_ID, CLOCK_OBJECT_ID, } from './constants.js';
+export type { CreateContinuousStreamConfig, CreateOnDemandStreamConfig, TickConfig, PayConfig, RevokeConfig, TopUpConfig, AddSplitConfig, RemoveSplitConfig, DestroyEmptyConfig, StreamCreatedEvent, PaymentSentEvent, StreamRevokedEvent, StreamToppedUpEvent, SplitPaymentSentEvent, SplitAddedEvent, SplitRemovedEvent, PiperEvent, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAGH,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAGnC,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACL,wBAAwB,EACxB,eAAe,GAChB,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EAEV,4BAA4B,EAC5B,0BAA0B,EAC1B,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EAElB,kBAAkB,EAClB,gBAAgB,EAChB,kBAAkB,EAClB,mBAAmB,EACnB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,UAAU,GACX,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,30 @@
+/**
+ * @usepiper/sdk — Piper Protocol TypeScript SDK
+ *
+ * A clean, typed interface for building Programmable Transaction Blocks (PTBs)
+ * that interact with the Piper Move contracts on Sui.
+ *
+ * @example
+ * ```typescript
+ * import { Transaction } from '@mysten/sui/transactions';
+ * import { Piper, extractStreamId } from '@usepiper/sdk';
+ *
+ * const tx = new Transaction();
+ * const stream = Piper.createContinuousStream(tx, {
+ *   coin: myCoinId,
+ *   coinType: '0x2::sui::SUI',
+ *   flowRate: 100,
+ *   recipient: '0xRecipient',
+ * });
+ * tx.transferObjects([stream], tx.pure.address(myAddress));
+ * ```
+ *
+ * @packageDocumentation
+ */
+// Core class
+export { Piper } from './piper.js';
+// Utility functions
+export { extractStreamId, calculateFlowRate, parsePiperEvents, } from './utils.js';
+// Constants
+export { PIPER_TESTNET_PACKAGE_ID, CLOCK_OBJECT_ID, } from './constants.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,aAAa;AACb,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,oBAAoB;AACpB,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,gBAAgB,GACjB,MAAM,YAAY,CAAC;AAEpB,YAAY;AACZ,OAAO,EACL,wBAAwB,EACxB,eAAe,GAChB,MAAM,gBAAgB,CAAC"}

package/dist/piper.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Piper SDK — Core Class
+ *
+ * Static methods that append Move calls to a Sui `Transaction`.
+ * Each method maps directly to a public function in the piper::stream Move module.
+ *
+ * Move function signatures (from piper-move/sources/stream.move):
+ *
+ *   create_stream<T>(coin: Coin<T>, flow_rate: u64, recipient: address, clock: &Clock, ctx: &mut TxContext): Stream<T>
+ *   create_on_demand_stream<T>(coin: Coin<T>, recipient: address, authorized_spender: address, clock: &Clock, ctx: &mut TxContext): Stream<T>
+ *   tick<T>(stream: &mut Stream<T>, clock: &Clock, ctx: &mut TxContext)
+ *   pay<T>(stream: &mut Stream<T>, amount: u64, clock: &Clock, ctx: &mut TxContext)
+ *   revoke<T>(stream: &mut Stream<T>, ctx: &mut TxContext): Coin<T>
+ *   top_up<T>(stream: &mut Stream<T>, coin: Coin<T>)
+ *   add_split<T>(stream: &mut Stream<T>, recipient: address, percent: u8, ctx: &mut TxContext)
+ *   remove_split<T>(stream: &mut Stream<T>, index: u64, ctx: &mut TxContext)
+ *   destroy_empty<T>(stream: Stream<T>)
+ */
+import { Transaction } from '@mysten/sui/transactions';
+import type { TransactionResult } from '@mysten/sui/transactions';
+import type { CreateContinuousStreamConfig, CreateOnDemandStreamConfig, TickConfig, PayConfig, RevokeConfig, TopUpConfig, AddSplitConfig, RemoveSplitConfig, DestroyEmptyConfig } from './types.js';
+/**
+ * The main Piper SDK class.
+ *
+ * All methods are static — there's no instance state.
+ * Call `Piper.setPackageId()` once at startup (or use the testnet default),
+ * then use any method to append Move calls to a `Transaction`.
+ */
+export declare class Piper {
+    /** The configured Move package ID */
+    private static _packageId;
+    /**
+     * Sets the Move package ID for all subsequent calls.
+     * Defaults to the Piper testnet package.
+     */
+    static setPackageId(packageId: string): void;
+    /**
+     * Returns the currently configured package ID.
+     * @throws if no package ID has been set and the default has been cleared.
+     */
+    static getPackageId(): string;
+    /**
+     * Creates a continuous (time-based) stream.
+     *
+     * Move: `piper::stream::create_stream<T>(coin, flow_rate, recipient, clock, ctx): Stream<T>`
+     *
+     * @returns A `TransactionResult` representing the created `Stream<T>` object.
+     *          You must transfer or share this object in the same transaction.
+     */
+    static createContinuousStream(tx: Transaction, config: CreateContinuousStreamConfig): TransactionResult;
+    /**
+     * Creates an on-demand (pay-per-use) stream.
+     *
+     * Move: `piper::stream::create_on_demand_stream<T>(coin, recipient, authorized_spender, clock, ctx): Stream<T>`
+     *
+     * @returns A `TransactionResult` representing the created `Stream<T>` object.
+     *          You must transfer or share this object in the same transaction.
+     */
+    static createOnDemandStream(tx: Transaction, config: CreateOnDemandStreamConfig): TransactionResult;
+    /**
+     * Shares a stream object so it can be autonomously ticked by anyone.
+     * This is the recommended way to handle newly created continuous streams.
+     *
+     * @param tx The Transaction
+     * @param stream The TransactionResult from createContinuousStream
+     * @param coinType The type of the coin in the stream
+     */
+    static shareStream(tx: Transaction, stream: TransactionResult, coinType: string): void;
+    /**
+     * Triggers a payment tick on a continuous stream.
+     * Permissionless — anyone can call this.
+     *
+     * Move: `piper::stream::tick<T>(stream, clock, ctx)`
+     *
+     * The Move function handles all coin transfers internally.
+     * Funds are sent directly to the primary recipient and any split recipients on-chain.
+     */
+    static tick(tx: Transaction, config: TickConfig): void;
+    /**
+     * Performs an on-demand payment from a pay-per-use stream.
+     * Must be called by the `authorizedSpender` — the transaction must be
+     * signed by the spender's key.
+     *
+     * Move: `piper::stream::pay<T>(stream, amount, clock, ctx)`
+     */
+    static pay(tx: Transaction, config: PayConfig): void;
+    /**
+     * Revokes a stream and returns the remaining balance as a `Coin<T>`.
+     * Only the stream creator can call this (enforced on-chain).
+     *
+     * Move: `piper::stream::revoke<T>(stream, clock, ctx): Coin<T>`
+     *
+     * @returns A `TransactionResult` representing the remaining `Coin<T>`.
+     *          You must transfer or consume this coin in the same transaction.
+     */
+    static revoke(tx: Transaction, config: RevokeConfig): TransactionResult;
+    /**
+     * Adds additional funds to an existing stream.
+     * Anyone can top up a stream.
+     *
+     * Move: `piper::stream::top_up<T>(stream, coin)`
+     */
+    static topUp(tx: Transaction, config: TopUpConfig): void;
+    /**
+     * Adds a percentage-based split recipient to a stream.
+     * Only the stream creator can manage splits (enforced on-chain).
+     * Total split percentages cannot exceed 100%.
+     *
+     * Move: `piper::stream::add_split<T>(stream, recipient, percent, ctx)`
+     */
+    static addSplit(tx: Transaction, config: AddSplitConfig): void;
+    /**
+     * Removes a split by index.
+     * Only the stream creator can manage splits (enforced on-chain).
+     *
+     * Move: `piper::stream::remove_split<T>(stream, index, ctx)`
+     */
+    static removeSplit(tx: Transaction, config: RemoveSplitConfig): void;
+    /**
+     * Destroys an inactive stream with zero balance.
+     * Deletes the `Stream` object from on-chain storage.
+     *
+     * Move: `piper::stream::destroy_empty<T>(stream)`
+     *
+     * Note: The stream is consumed by value — if you pass a string ID,
+     * the SDK resolves it as an owned object.
+     */
+    static destroyEmpty(tx: Transaction, config: DestroyEmptyConfig): void;
+}
+//# sourceMappingURL=piper.d.ts.map

package/dist/piper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"piper.d.ts","sourceRoot":"","sources":["../src/piper.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,KAAK,EAAuB,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAEvF,OAAO,KAAK,EACV,4BAA4B,EAC5B,0BAA0B,EAC1B,UAAU,EACV,SAAS,EACT,YAAY,EACZ,WAAW,EACX,cAAc,EACd,iBAAiB,EACjB,kBAAkB,EACnB,MAAM,YAAY,CAAC;AAiBpB;;;;;;GAMG;AACH,qBAAa,KAAK;IAChB,qCAAqC;IACrC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAoC;IAI7D;;;OAGG;IACH,MAAM,CAAC,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI5C;;;OAGG;IACH,MAAM,CAAC,YAAY,IAAI,MAAM;IAW7B;;;;;;;OAOG;IACH,MAAM,CAAC,sBAAsB,CAC3B,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,4BAA4B,GACnC,iBAAiB;IAepB;;;;;;;OAOG;IACH,MAAM,CAAC,oBAAoB,CACzB,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,0BAA0B,GACjC,iBAAiB;IAepB;;;;;;;OAOG;IACH,MAAM,CAAC,WAAW,CAChB,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,iBAAiB,EACzB,QAAQ,EAAE,MAAM,GACf,IAAI;IAWP;;;;;;;;OAQG;IACH,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI;IAatD;;;;;;OAMG;IACH,MAAM,CAAC,GAAG,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,SAAS,GAAG,IAAI;IAcpD;;;;;;;;OAQG;IACH,MAAM,CAAC,MAAM,CACX,EAAE,EAAE,WAAW,EACf,MAAM,EAAE,YAAY,GACnB,iBAAiB;IAapB;;;;;OAKG;IACH,MAAM,CAAC,KAAK,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI;IAexD;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,cAAc,GAAG,IAAI;IAc9D;;;;;OAKG;IACH,MAAM,CAAC,WAAW,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,iBAAiB,GAAG,IAAI;IAepE;;;;;;;;OAQG;IACH,MAAM,CAAC,YAAY,CAAC,EAAE,EAAE,WAAW,EAAE,MAAM,EAAE,kBAAkB,GAAG,IAAI;CAWvE"}