@waterx/sdk 3.0.1 → 3.1.0

package/dist/cjs/src/prediction/fetch.js

@@ -0,0 +1,294 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReturnBytes = extractReturnBytes;
+exports.getRegistry = getRegistry;
+exports.getOrder = getOrder;
+exports.getPosition = getPosition;
+exports.getMarketById = getMarketById;
+exports.getMarketByKey = getMarketByKey;
+exports.getMarketExposure = getMarketExposure;
+exports.getMarketExposureByKey = getMarketExposureByKey;
+exports.getOrderCursor = getOrderCursor;
+exports.getPositionCursor = getPositionCursor;
+exports.getUnresolvedMarketCursor = getUnresolvedMarketCursor;
+exports.getResolvedMarketCursor = getResolvedMarketCursor;
+exports.getAccountIds = getAccountIds;
+exports.getAccountData = getAccountData;
+exports.getAccountOrderIds = getAccountOrderIds;
+exports.getAccountPositionIds = getAccountPositionIds;
+exports.getAccountOrderIdsByMarketId = getAccountOrderIdsByMarketId;
+exports.getAccountPositionIdsByMarketId = getAccountPositionIdsByMarketId;
+exports.isKeeper = isKeeper;
+exports.getKeeperAddresses = getKeeperAddresses;
+exports.getAllowedVersions = getAllowedVersions;
+exports.isPredictionProtocolAssetAllowed = isPredictionProtocolAssetAllowed;
+const bcs_1 = require("@mysten/sui/bcs");
+const transactions_1 = require("@mysten/sui/transactions");
+const bcs_ts_1 = require("./bcs.js");
+const utils_ts_1 = require("./utils.js");
+function extractReturnBytes(result, commandIndex = 0, returnIndex = 0) {
+    if (result.$kind === "FailedTransaction") {
+        const err = result.FailedTransaction.status.error;
+        throw new Error(`Simulate transaction failed: ${err?.message ?? JSON.stringify(err)}`);
+    }
+    const bcsBytes = result.commandResults?.[commandIndex]?.returnValues?.[returnIndex]?.bcs;
+    if (bcsBytes)
+        return new Uint8Array(bcsBytes);
+    const legacy = result.results?.[commandIndex]?.returnValues?.[returnIndex];
+    if (legacy)
+        return new Uint8Array(legacy[0]);
+    throw new Error(`No return value at command[${commandIndex}].returnValues[${returnIndex}]`);
+}
+async function getRegistry(client, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::registry`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapRegistryView)(bcs_ts_1.RegistryViewBcs.parse(extractReturnBytes(result)));
+}
+async function getOrder(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::order`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.orderId)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapOrderView)(bcs_ts_1.OrderViewBcs.parse(extractReturnBytes(result)));
+}
+async function getPosition(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::position`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.positionId)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapPositionView)(bcs_ts_1.PositionViewBcs.parse(extractReturnBytes(result)));
+}
+async function getMarketById(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::market_by_id`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapMarketView)(bcs_ts_1.MarketViewBcs.parse(extractReturnBytes(result)));
+}
+async function getMarketByKey(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::market_by_key`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapMarketView)(bcs_ts_1.MarketViewBcs.parse(extractReturnBytes(result)));
+}
+async function getMarketExposure(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::market_exposure`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapMarketExposure)(bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 0)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 1)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 2)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 3)));
+}
+async function getMarketExposureByKey(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::waterx_prediction::market_exposure_by_key`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapMarketExposure)(bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 0)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 1)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 2)), bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 3)));
+}
+async function readCursor(client, functionName, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::${functionName}`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapCursorView)(bcs_1.bcs.u64().parse(extractReturnBytes(result, 0, 0)), bcs_1.bcs.option(bcs_1.bcs.u64()).parse(extractReturnBytes(result, 0, 1)), bcs_1.bcs.option(bcs_1.bcs.u64()).parse(extractReturnBytes(result, 0, 2)));
+}
+function getOrderCursor(client, params = {}) {
+    return readCursor(client, "order_cursor", params);
+}
+function getPositionCursor(client, params = {}) {
+    return readCursor(client, "position_cursor", params);
+}
+function getUnresolvedMarketCursor(client, params = {}) {
+    return readCursor(client, "unresolved_market_cursor", params);
+}
+function getResolvedMarketCursor(client, params = {}) {
+    return readCursor(client, "resolved_market_cursor", params);
+}
+/**
+ * Registry account ids (`0x2::object::ID`) for an owner via `waterx_account::account::account_ids`.
+ * Use these ids with `getAccountData`, `deposit`, and `placeOrder` — not Suiscan "Account" object addresses.
+ */
+async function getAccountIds(client, params) {
+    const pkg = (0, utils_ts_1.resolveAccountPackageId)(client, params.accountPackageId);
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${pkg}::account::account_ids`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.address(params.owner),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs.vector(bcs_1.bcs.Address).parse(extractReturnBytes(result));
+}
+async function getAccountData(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::account`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return (0, bcs_ts_1.mapAccountDataView)(bcs_ts_1.AccountDataViewBcs.parse(extractReturnBytes(result)));
+}
+async function getAccountOrderIds(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::account_order_ids`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs
+        .vector(bcs_1.bcs.u64())
+        .parse(extractReturnBytes(result))
+        .map((v) => BigInt(v));
+}
+async function getAccountPositionIds(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::account_position_ids`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            tx.pure.u64((0, utils_ts_1.toBigInt)(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs
+        .vector(bcs_1.bcs.u64())
+        .parse(extractReturnBytes(result))
+        .map((v) => BigInt(v));
+}
+async function getAccountOrderIdsByMarketId(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::account_order_ids_by_market_id`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs
+        .vector(bcs_1.bcs.u64())
+        .parse(extractReturnBytes(result))
+        .map((v) => BigInt(v));
+}
+async function getAccountPositionIdsByMarketId(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::view::account_position_ids_by_market_id`,
+        typeArguments: [(0, utils_ts_1.resolveSettlementCoinType)(client, params.settlementCoinType)],
+        arguments: [
+            tx.object((0, utils_ts_1.resolveMarketRegistry)(client, params.marketRegistry)),
+            tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            (0, utils_ts_1.marketIdArg)(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs
+        .vector(bcs_1.bcs.u64())
+        .parse(extractReturnBytes(result))
+        .map((v) => BigInt(v));
+}
+async function isKeeper(client, params) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::global_config::is_keeper`,
+        arguments: [
+            tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig)),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs.bool().parse(extractReturnBytes(result));
+}
+async function getKeeperAddresses(client, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::global_config::keeper_addresses`,
+        arguments: [tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig))],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs.vector(bcs_1.bcs.Address).parse(extractReturnBytes(result));
+}
+async function getAllowedVersions(client, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolvePackageId)(client, params.packageId)}::global_config::allowed_versions`,
+        arguments: [tx.object((0, utils_ts_1.resolveGlobalConfig)(client, params.globalConfig))],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs
+        .vector(bcs_1.bcs.u16())
+        .parse(extractReturnBytes(result))
+        .map((v) => Number(v));
+}
+async function isPredictionProtocolAssetAllowed(client, params = {}) {
+    const tx = new transactions_1.Transaction();
+    tx.moveCall({
+        target: `${(0, utils_ts_1.resolveAccountPackageId)(client, params.accountPackageId)}::account::is_protocol_asset_allowed`,
+        typeArguments: [
+            `${(0, utils_ts_1.resolvePackageId)(client, params.predictionPackageId)}::account_data::WaterXPrediction`,
+            params.coinType ?? client.settlementCoinType(),
+        ],
+        arguments: [tx.object((0, utils_ts_1.resolveAccountRegistry)(client, params.accountRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return bcs_1.bcs.bool().parse(extractReturnBytes(result));
+}

package/dist/cjs/src/prediction/gift-link.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Browser-safe re-exports of gift URL / KDF crypto helpers (no PredictClient / RPC).
+ * Full gift runtime (PTB builders + simulate reads) lives in `./gift.ts`.
+ */
+export { base64UrlNoPadDecode, base64UrlNoPadEncode, buildGiftClaimMessage, deriveGiftKeypair, encodeGiftUrl, generateGiftSeed, parseGiftUrl, signGiftClaim, } from "./gift.ts";
+export type { GiftUrlParts } from "./gift.ts";

package/dist/cjs/src/prediction/gift-link.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signGiftClaim = exports.parseGiftUrl = exports.generateGiftSeed = exports.encodeGiftUrl = exports.deriveGiftKeypair = exports.buildGiftClaimMessage = exports.base64UrlNoPadEncode = exports.base64UrlNoPadDecode = void 0;
+/**
+ * Browser-safe re-exports of gift URL / KDF crypto helpers (no PredictClient / RPC).
+ * Full gift runtime (PTB builders + simulate reads) lives in `./gift.ts`.
+ */
+var gift_ts_1 = require("./gift.js");
+Object.defineProperty(exports, "base64UrlNoPadDecode", { enumerable: true, get: function () { return gift_ts_1.base64UrlNoPadDecode; } });
+Object.defineProperty(exports, "base64UrlNoPadEncode", { enumerable: true, get: function () { return gift_ts_1.base64UrlNoPadEncode; } });
+Object.defineProperty(exports, "buildGiftClaimMessage", { enumerable: true, get: function () { return gift_ts_1.buildGiftClaimMessage; } });
+Object.defineProperty(exports, "deriveGiftKeypair", { enumerable: true, get: function () { return gift_ts_1.deriveGiftKeypair; } });
+Object.defineProperty(exports, "encodeGiftUrl", { enumerable: true, get: function () { return gift_ts_1.encodeGiftUrl; } });
+Object.defineProperty(exports, "generateGiftSeed", { enumerable: true, get: function () { return gift_ts_1.generateGiftSeed; } });
+Object.defineProperty(exports, "parseGiftUrl", { enumerable: true, get: function () { return gift_ts_1.parseGiftUrl; } });
+Object.defineProperty(exports, "signGiftClaim", { enumerable: true, get: function () { return gift_ts_1.signGiftClaim; } });

package/dist/cjs/src/prediction/gift.d.ts

@@ -0,0 +1,242 @@
+/**
+ * waterx_prediction_gift / claimable_link bindings.
+ *
+ * Three responsibilities:
+ *
+ * 1. **KDF + signed-message format** — turn a 16-byte URL seed into an
+ *    Ed25519 keypair (sha256 over a package-prefixed domain) and build
+ *    the exact 92-byte payload `claim_share` verifies on chain.
+ *    Every byte here must match `claimable_link.move` — one wrong byte
+ *    and outstanding URLs break.
+ *
+ * 2. **URL helpers + offline gift-address derivation** — base64url(no-pad)
+ *    encode/decode of the seed (URL fragment), and `deriveGiftAddress`
+ *    which mirrors `derived_object::derive_address` locally so a
+ *    receiver can compute `gift_id` from the seed without any RPC.
+ *
+ * 3. **PTB builders + simulate reads** — `createGift` / `claimShare` /
+ *    `deleteGift` matching the on-chain entrypoints, plus single-RPC
+ *    `simulateTransaction`-based read helpers for the view fns.
+ */
+import { Ed25519Keypair } from "@mysten/sui/keypairs/ed25519";
+import { Transaction } from "@mysten/sui/transactions";
+import type { PredictClient } from "./client.ts";
+import type { AccountIdentityParams, IdArgument, Selection } from "./types.ts";
+export interface GiftBaseParams {
+    /** `waterx_prediction_gift` package id. Defaults to `client.waterxPredictionGiftPackageId()`. */
+    giftPackageId?: string;
+    /**
+     * `waterx_prediction_gift` *original* (first-published) package id, used
+     * ONLY for the `GiftKey` type tag in {@link deriveGiftAddress}. Defaults to
+     * `client.waterxPredictionGiftTypeOriginId()` (config `original_id`, falling
+     * back to `giftPackageId`/`published_at`). Distinct from `giftPackageId`,
+     * which selects the *runtime* package for moveCall targets — after a package
+     * upgrade the two diverge, and only the original id reproduces the on-chain
+     * `gift_id`. Override only for offline derivation against a custom deploy.
+     */
+    giftTypeOriginId?: string;
+    /** `ClaimableLinkConfig` object id. Defaults to `client.claimableLinkConfigId()`. */
+    claimableLinkConfig?: string;
+    /** Collateral / settlement coin type for the position's `Gift<T>`. Defaults to `client.settlementCoinType()`. */
+    settlementCoinType?: string;
+}
+export interface GiftReferralParams {
+    /** `waterx_referral` package id. Defaults to `client.waterxReferralPackageId()`. */
+    referralPackageId?: string;
+    /** `ReferralTable` object id. Defaults to `client.referralTableId()`. */
+    referralTable?: string;
+}
+export declare function base64UrlNoPadEncode(bytes: Uint8Array): string;
+export declare function base64UrlNoPadDecode(value: string): Uint8Array;
+/** CSPRNG-generated 16-byte URL seed. Uses `globalThis.crypto.getRandomValues`. */
+export declare function generateGiftSeed(): Uint8Array;
+export interface GiftUrlParts {
+    /** Optional URL base (`https://waterx.io`). Empty → fragment-only path `/g/#<seed>`. */
+    host?: string;
+    /** Path prefix before `#<seed>`. Defaults to `/g/`. */
+    path?: string;
+}
+/** Build the share URL: `<host><path>#<base64urlnopad(seed)>`. */
+export declare function encodeGiftUrl(seed: Uint8Array, parts?: GiftUrlParts): string;
+/** Parse a share URL or fragment-only string back into the raw seed bytes. */
+export declare function parseGiftUrl(url: string): {
+    seed: Uint8Array;
+};
+/**
+ * Off-chain KDF: `sha256(KDF_DOMAIN || seed)` → 32-byte Ed25519 secret.
+ * Bytes MUST match across SDK versions and downstream integrations or
+ * every outstanding URL breaks.
+ */
+export declare function deriveGiftKeypair(seed: Uint8Array): Ed25519Keypair;
+/**
+ * Reproduce the bytes `claim_share` verifies:
+ * `DOMAIN_CLAIM || bcs(gift_id) || bcs(sender)` = 28 + 32 + 32 = 92 bytes.
+ */
+export declare function buildGiftClaimMessage(giftId: string, sender: string): Uint8Array;
+/**
+ * Raw Ed25519 over the claim payload — NOT Sui-intent-prefixed.
+ * `claim_share` calls `ed25519::ed25519_verify` directly, so any
+ * intent prefix would break verification.
+ */
+export declare function signGiftClaim(giftKeypair: Ed25519Keypair, giftId: string, sender: string): Promise<Uint8Array>;
+/**
+ * Compute the `gift_id` that `create_gift` will produce for the given
+ * pubkey, offline. No RPC. Mirrors `claimable_link::derive_gift_address`.
+ *
+ * The `GiftKey` type tag is keyed on the gift package's *original* id
+ * (via {@link resolveGiftTypeOriginId}), NOT `published_at`. On Sui a
+ * struct's type identity stays pinned to its defining package's original
+ * id and never advances across upgrades, so `derive_gift_address`
+ * hashes `GiftKey` under that original id. Using `published_at` here would
+ * silently diverge from the chain after the first package upgrade, yielding
+ * the wrong `gift_id` for every gift. The moveCall targets elsewhere in
+ * this module correctly stay on `published_at` (latest code).
+ */
+export declare function deriveGiftAddress(client: PredictClient, pubkey: Uint8Array, params?: GiftBaseParams): string;
+export interface CreateGiftParams extends GiftBaseParams, GiftReferralParams, AccountIdentityParams {
+    /** wxa account id (`0x2::object::ID`) that owns the source position. */
+    sourceAccountId: IdArgument;
+    /** Numeric `position_id` of the position to lock. */
+    sourcePositionId: bigint | number | string;
+    /** 32-byte gift pubkey (from `deriveGiftKeypair(seed).getPublicKey().toRawBytes()`). */
+    pubkey: Uint8Array;
+    /** Number of slices, 1..=MAX_SHARES_PER_GIFT. */
+    shareCount: bigint | number | string;
+    /** Absolute expiry in milliseconds. Must be strictly in the future. */
+    expiresAtMs: bigint | number | string;
+    /** Optional referral code applied to every claimer (idempotent). */
+    referralCode?: string | null;
+    /** Override `MarketRegistry<T>` id. Defaults to `client.marketRegistry()`. */
+    marketRegistry?: string;
+    /** Override `AccountRegistry` id. Defaults to `client.accountRegistry()`. */
+    accountRegistry?: string;
+}
+/**
+ * Lock one position behind `pubkey` and share it as a gift. Adds a
+ * single `claimable_link::create_gift<T>` call to `tx` using the
+ * caller's `bucket_framework::account::request` as the source-owner
+ * authority. The transaction sender (`ctx.sender()`) must be the owner
+ * of `sourceAccountId`.
+ */
+export declare function createGift(client: PredictClient, tx: Transaction, params: CreateGiftParams): Transaction;
+export interface ClaimShareParams extends GiftBaseParams, GiftReferralParams {
+    /** Shared `Gift<T>` object id. Derive locally via `deriveGiftAddress`. */
+    giftId: string;
+    /** Raw 64-byte Ed25519 signature over `buildGiftClaimMessage(giftId, sender)`. */
+    sig: Uint8Array;
+    /**
+     * Recipient wxa account id, or `null`/`undefined` to land in the
+     * claimer's main wxa (auto-created with alias `"main"` if the
+     * claimer has none yet).
+     */
+    recipientAccountId?: IdArgument | null;
+    /** prediction `GlobalConfig` id. Defaults to `client.globalConfigId()`. */
+    globalConfig?: string;
+    /** prediction `MarketRegistry<T>` id. Defaults to `client.marketRegistry()`. */
+    marketRegistry?: string;
+    /** `waterx_account::AccountRegistry` id. Defaults to `client.accountRegistry()`. */
+    accountRegistry?: string;
+}
+/**
+ * Claim one slice of a gift. The signature must be raw Ed25519 (NOT
+ * Sui-intent-prefixed) over `DOMAIN_CLAIM || gift_id || sender`.
+ * Pre-flight: fetch the gift and check `claimed_count < share_count`,
+ * `now < expires_at_ms`, and `!claimed_addresses.contains(sender)` to
+ * surface "already claimed" client-side instead of paying gas to abort.
+ */
+export declare function claimShare(client: PredictClient, tx: Transaction, params: ClaimShareParams): Transaction;
+export interface DeleteGiftParams extends GiftBaseParams, AccountIdentityParams {
+    /** Shared `Gift<T>` object id to consume. */
+    giftId: string;
+}
+/**
+ * Creator-driven hard delete. Consumes the `Gift<T>` by value and
+ * removes it from `config.creator_gifts[creator]`. The source position
+ * stays on the creator's wxa; nothing to refund. Skips the paused gate
+ * — cancel must work even when the package is paused.
+ */
+export declare function deleteGift(client: PredictClient, tx: Transaction, params: DeleteGiftParams): Transaction;
+export interface GiftView {
+    giftId: string;
+    creator: string;
+    creatorAccountId: string;
+    sourcePositionId: bigint;
+    marketId: Uint8Array;
+    marketIdHex: string;
+    selection: Selection;
+    totalSpend: bigint;
+    spendPerShare: bigint;
+    lockedOddsCents: bigint;
+    pubkey: Uint8Array;
+    shareCount: bigint;
+    claimedCount: bigint;
+    claimedAddresses: string[];
+    baseShareAmount: bigint;
+    extraShareLinks: bigint;
+    totalShares: bigint;
+    remainingShares: bigint;
+    referralCode: string | null;
+    createdAtMs: bigint;
+    expiresAtMs: bigint;
+}
+/**
+ * Fetch a single gift's full view in one RPC by batching every getter
+ * into one simulated PTB. Decodes each `commandResults[i].returnValues[0]`
+ * into the corresponding TypeScript field.
+ */
+export declare function getGift(client: PredictClient, params: GiftBaseParams & {
+    giftId: string;
+}): Promise<GiftView>;
+/** Live gift IDs for a creator. Order isn't preserved — sort by `createdAtMs`. */
+export declare function getCreatorGiftIds(client: PredictClient, params: GiftBaseParams & {
+    creator: string;
+}): Promise<string[]>;
+export declare function getCreatorGiftCount(client: PredictClient, params: GiftBaseParams & {
+    creator: string;
+}): Promise<bigint>;
+/**
+ * Global controller delegate address. Same value for every creator,
+ * stable for the package's lifetime. Surface on FE so creators can
+ * verify the right delegate is registered on their wxa.
+ */
+export declare function getGiftControllerAddress(client: PredictClient, params?: GiftBaseParams): Promise<string>;
+export declare function getGiftConfigPaused(client: PredictClient, params?: GiftBaseParams): Promise<boolean>;
+export declare function getGiftHasClaimed(client: PredictClient, params: GiftBaseParams & {
+    giftId: string;
+    addr: string;
+}): Promise<boolean>;
+export interface BuildCreateGiftFlowResult {
+    tx: Transaction;
+    /** Raw 16-byte seed. Encode into the share URL with `encodeGiftUrl`. */
+    seed: Uint8Array;
+    /** Predicted gift ID (computed locally from `(config, pubkey)`). */
+    giftId: string;
+    /** 32-byte gift pubkey, in case the caller wants to log/store it. */
+    pubkey: Uint8Array;
+}
+/**
+ * One-shot: generate a fresh seed, derive the gift keypair + pubkey,
+ * compute the predicted `gift_id`, and add the `create_gift` call to
+ * `tx`. The caller signs + executes `tx` and then renders the URL via
+ * `encodeGiftUrl(seed, …)`.
+ */
+export declare function buildCreateGiftFlow(client: PredictClient, tx: Transaction, params: Omit<CreateGiftParams, "pubkey">): BuildCreateGiftFlowResult;
+export interface BuildClaimShareFlowParams extends Omit<ClaimShareParams, "sig" | "giftId"> {
+    /** The 16-byte seed parsed from the share URL fragment. */
+    seed: Uint8Array;
+    /** The transaction sender (becomes `ctx.sender()`). Bound into the sig. */
+    sender: string;
+    /** Optional override — defaults to `deriveGiftAddress(client, pubkey)`. */
+    giftId?: string;
+}
+export interface BuildClaimShareFlowResult {
+    tx: Transaction;
+    giftId: string;
+    sig: Uint8Array;
+}
+/**
+ * One-shot: derive the gift keypair from `seed`, compute `gift_id`,
+ * sign the claim payload bound to `sender`, and add the `claim_share`
+ * call to `tx`. Caller signs + executes `tx` with `sender`'s keypair.
+ */
+export declare function buildClaimShareFlow(client: PredictClient, tx: Transaction, params: BuildClaimShareFlowParams): Promise<BuildClaimShareFlowResult>;