@waterx/predict-sdk 0.1.0

package/dist/src/client.d.ts

@@ -0,0 +1,60 @@
+import type { Signer } from "@mysten/sui/cryptography";
+import type { SuiClientTypes } from "@mysten/sui/client";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import type { Transaction } from "@mysten/sui/transactions";
+import { type Network, type TestnetSettlementAsset } from "./constants.ts";
+export interface PredictConfig {
+    network: Network;
+    grpcUrl?: string;
+    /** waterx_prediction package ID. */
+    packageId: string;
+    /** bucket_v2_framework package ID for AccountRequest constructors. */
+    bucketFrameworkPackageId: string;
+    /** waterx_account package ID for account helpers. */
+    waterxAccountPackageId: string;
+    /** Shared waterx_prediction::global_config::GlobalConfig object ID. */
+    globalConfig?: string;
+    /** Shared waterx_prediction::waterx_prediction::MarketRegistry<T> object ID. */
+    marketRegistry?: string;
+    /** Shared waterx_account::account::AccountRegistry object ID. */
+    accountRegistry?: string;
+    /** Default settlement coin type used by prediction registry calls. */
+    settlementCoinType: string;
+}
+export interface TestnetConfigParams {
+    grpcUrl?: string;
+    settlement?: TestnetSettlementAsset;
+    packageId?: string;
+    bucketFrameworkPackageId?: string;
+    waterxAccountPackageId?: string;
+    globalConfig?: string;
+    marketRegistry?: string;
+    accountRegistry?: string;
+    settlementCoinType?: string;
+}
+export declare function createTestnetConfig(params?: TestnetConfigParams): PredictConfig;
+export declare class PredictClient {
+    readonly grpcClient: SuiGrpcClient;
+    readonly config: PredictConfig;
+    constructor(config: PredictConfig);
+    static testnet(params?: TestnetConfigParams): PredictClient;
+    getObject(objectId: string): Promise<SuiClientTypes.GetObjectResponse<{}>>;
+    getObjects(objectIds: string[]): Promise<SuiClientTypes.GetObjectsResponse<{}>>;
+    listOwnedObjects(owner: string): Promise<SuiClientTypes.ListOwnedObjectsResponse<{}>>;
+    listCoins(params: {
+        owner: string;
+        coinType?: string;
+    }): Promise<SuiClientTypes.ListCoinsResponse>;
+    waitForTransaction(digest: string): Promise<SuiClientTypes.TransactionResult<{}>>;
+    simulate(tx: Transaction): Promise<SuiClientTypes.SimulateTransactionResult<{
+        commandResults: true;
+    }>>;
+    signAndExecuteTransaction<Include extends SuiClientTypes.TransactionInclude = {}>(params: {
+        signer: {
+            toSuiAddress: () => string;
+        } & Signer;
+        transaction: Transaction | Uint8Array;
+        additionalSignatures?: string[];
+        include?: Include & SuiClientTypes.TransactionInclude;
+    }): Promise<SuiClientTypes.TransactionResult<Include & SuiClientTypes.TransactionInclude>>;
+}

package/dist/src/client.js

@@ -0,0 +1,59 @@
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+import { TESTNET_MARKET_REGISTRIES, TESTNET_OBJECTS, TESTNET_PACKAGE_IDS, TESTNET_SETTLEMENT_COIN_TYPES, } from "./constants.js";
+const GRPC_URLS = {
+    MAINNET: "https://fullnode.mainnet.sui.io:443",
+    TESTNET: "https://fullnode.testnet.sui.io:443",
+    DEVNET: "https://fullnode.devnet.sui.io:443",
+};
+export function createTestnetConfig(params = {}) {
+    const settlement = params.settlement ?? "USD";
+    return {
+        network: "TESTNET",
+        grpcUrl: params.grpcUrl,
+        packageId: params.packageId ?? TESTNET_PACKAGE_IDS.WATERX_PREDICTION,
+        bucketFrameworkPackageId: params.bucketFrameworkPackageId ?? TESTNET_PACKAGE_IDS.BUCKET_FRAMEWORK,
+        waterxAccountPackageId: params.waterxAccountPackageId ?? TESTNET_PACKAGE_IDS.WATERX_ACCOUNT,
+        globalConfig: params.globalConfig ?? TESTNET_OBJECTS.GLOBAL_CONFIG,
+        marketRegistry: params.marketRegistry ?? TESTNET_MARKET_REGISTRIES[settlement],
+        accountRegistry: params.accountRegistry ?? TESTNET_OBJECTS.ACCOUNT_REGISTRY,
+        settlementCoinType: params.settlementCoinType ?? TESTNET_SETTLEMENT_COIN_TYPES[settlement],
+    };
+}
+export class PredictClient {
+    grpcClient;
+    config;
+    constructor(config) {
+        this.config = config;
+        const network = config.network.toLowerCase();
+        const baseUrl = config.grpcUrl ??
+            (config.network === "LOCALNET" ? "http://127.0.0.1:9000" : GRPC_URLS[config.network]);
+        this.grpcClient = new SuiGrpcClient({ baseUrl, network });
+    }
+    static testnet(params = {}) {
+        return new PredictClient(createTestnetConfig(params));
+    }
+    getObject(objectId) {
+        return this.grpcClient.getObject({ objectId });
+    }
+    getObjects(objectIds) {
+        return this.grpcClient.getObjects({ objectIds });
+    }
+    listOwnedObjects(owner) {
+        return this.grpcClient.listOwnedObjects({ owner });
+    }
+    listCoins(params) {
+        return this.grpcClient.listCoins(params);
+    }
+    waitForTransaction(digest) {
+        return this.grpcClient.waitForTransaction({ digest });
+    }
+    async simulate(tx) {
+        return this.grpcClient.simulateTransaction({
+            transaction: tx,
+            include: { commandResults: true },
+        });
+    }
+    async signAndExecuteTransaction(params) {
+        return this.grpcClient.signAndExecuteTransaction(params);
+    }
+}

package/dist/src/constants.d.ts

@@ -0,0 +1,61 @@
+export type Network = "MAINNET" | "TESTNET" | "DEVNET" | "LOCALNET";
+export declare const CLOCK_OBJECT_ID = "0x6";
+/**
+ * Testnet deployment snapshot from WaterXProtocol/waterx-config.
+ */
+export declare const WATERX_CONFIG_SOURCE = "https://github.com/WaterXProtocol/waterx-config";
+export declare const TESTNET_CHAIN_ID = "4c78adac";
+export declare const TESTNET_PACKAGE_IDS: {
+    readonly BUCKET_FRAMEWORK: "0x0cdfc09284014fd36bbb19da8ab1c60056ca207d4c866e78dc01ca8e51dac790";
+    readonly WATERX_PREDICTION: "0xcd9385ff6414afeefb994a646af5c7451c5f88ab4c751f828453fbddb3d2f111";
+    readonly WATERX_ACCOUNT: "0x2d9b1eb3958fad8ff619d30d959351ecce851fcea231fa362b36d52c76b339b5";
+    readonly MOCK_USDC: "0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a";
+};
+export declare const TESTNET_OBJECTS: {
+    readonly ADMIN_CAP: "0x3afca689df306babe5ac83651268276989222fe47ffc5084f4df53a0b08421bf";
+    readonly GLOBAL_CONFIG: "0x6d3489019a0943f9015765826c732a3ba598ea1906f263d894ba5d6fad6346c1";
+    readonly ACCOUNT_REGISTRY: "0xde28a18a1cecb0486d77ef371b08695029e183bc6910455fbe2c5cb463cb0861";
+    readonly MARKET_REGISTRY_USD: "0x8bb484a7e8ee2a85c88265906bde08ac2897b4e34bbd2b9d4e7dacc39456c772";
+};
+export declare const TESTNET_MARKET_REGISTRIES: {
+    readonly USD: "0x8bb484a7e8ee2a85c88265906bde08ac2897b4e34bbd2b9d4e7dacc39456c772";
+};
+export declare const TESTNET_SETTLEMENT_COIN_TYPES: {
+    readonly USD: "0x3d6fd5e79c5134f94523f5d6d24a96ecf9f9af35bdbf9e6af87f5a6dbb032efe::usd::USD";
+};
+export type TestnetSettlementAsset = keyof typeof TESTNET_SETTLEMENT_COIN_TYPES;
+export declare const TESTNET_TYPES: {
+    readonly USD: "0x3d6fd5e79c5134f94523f5d6d24a96ecf9f9af35bdbf9e6af87f5a6dbb032efe::usd::USD";
+    readonly MOCK_USDC: "0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a::mock_usdc::MOCK_USDC";
+    /** @deprecated Prediction testnet settlement uses `TESTNET_TYPES.USD`. */
+    readonly USDC: "0x3d6fd5e79c5134f94523f5d6d24a96ecf9f9af35bdbf9e6af87f5a6dbb032efe::usd::USD";
+    readonly SUI: "0x2::sui::SUI";
+};
+export declare const PREDICTION_PERM_PLACE_ORDER: number;
+export declare const PREDICTION_PERM_CANCEL_ORDER: number;
+export declare const PREDICTION_PERM_CLAIM: number;
+export declare const PREDICTION_PERM_REQUEST_CLOSE: number;
+export declare const PREDICTION_PERM_ALL: number;
+export declare const ACCOUNT_PERM_WITHDRAW: number;
+export declare const ACCOUNT_PERM_MANAGE_DELEGATES: number;
+export declare const ACCOUNT_PERM_RECEIVE: number;
+export declare const ACCOUNT_PERM_ALL = 4294967295;
+export declare const PREDICTION_ERROR_CODES: {
+    readonly EBadStatus: 1;
+    readonly EMarketNotResolved: 3;
+    readonly EAlreadyResolved: 4;
+    readonly EBadPriceCap: 5;
+    readonly EFillExceedsMax: 6;
+    readonly EFillBelowMin: 7;
+    readonly EBadExpiry: 8;
+    readonly EBadPayment: 9;
+    readonly EMarketPaused: 10;
+    readonly EBelowMinReserve: 11;
+    readonly EMarketAlreadyResolved: 12;
+    readonly ECloseProceedsBelowMin: 13;
+    readonly EUnauthorized: 14;
+    readonly ENotAccountPosition: 16;
+    readonly EOrderInCooldown: 17;
+    readonly EOrderExpired: 18;
+    readonly EOrderNotExpired: 19;
+};

package/dist/src/constants.js

@@ -0,0 +1,62 @@
+export const CLOCK_OBJECT_ID = "0x6";
+/**
+ * Testnet deployment snapshot from WaterXProtocol/waterx-config.
+ */
+export const WATERX_CONFIG_SOURCE = "https://github.com/WaterXProtocol/waterx-config";
+export const TESTNET_CHAIN_ID = "4c78adac";
+export const TESTNET_PACKAGE_IDS = {
+    BUCKET_FRAMEWORK: "0x0cdfc09284014fd36bbb19da8ab1c60056ca207d4c866e78dc01ca8e51dac790",
+    WATERX_PREDICTION: "0xcd9385ff6414afeefb994a646af5c7451c5f88ab4c751f828453fbddb3d2f111",
+    WATERX_ACCOUNT: "0x2d9b1eb3958fad8ff619d30d959351ecce851fcea231fa362b36d52c76b339b5",
+    MOCK_USDC: "0x7ccd477e884ec74f960b23a8b34b7d87999e4d7ee0dde738a0c25f46200f201a",
+};
+export const TESTNET_OBJECTS = {
+    ADMIN_CAP: "0x3afca689df306babe5ac83651268276989222fe47ffc5084f4df53a0b08421bf",
+    GLOBAL_CONFIG: "0x6d3489019a0943f9015765826c732a3ba598ea1906f263d894ba5d6fad6346c1",
+    ACCOUNT_REGISTRY: "0xde28a18a1cecb0486d77ef371b08695029e183bc6910455fbe2c5cb463cb0861",
+    MARKET_REGISTRY_USD: "0x8bb484a7e8ee2a85c88265906bde08ac2897b4e34bbd2b9d4e7dacc39456c772",
+};
+export const TESTNET_MARKET_REGISTRIES = {
+    USD: TESTNET_OBJECTS.MARKET_REGISTRY_USD,
+};
+export const TESTNET_SETTLEMENT_COIN_TYPES = {
+    USD: "0x3d6fd5e79c5134f94523f5d6d24a96ecf9f9af35bdbf9e6af87f5a6dbb032efe::usd::USD",
+};
+export const TESTNET_TYPES = {
+    USD: TESTNET_SETTLEMENT_COIN_TYPES.USD,
+    MOCK_USDC: `${TESTNET_PACKAGE_IDS.MOCK_USDC}::mock_usdc::MOCK_USDC`,
+    /** @deprecated Prediction testnet settlement uses `TESTNET_TYPES.USD`. */
+    USDC: TESTNET_SETTLEMENT_COIN_TYPES.USD,
+    SUI: "0x2::sui::SUI",
+};
+export const PREDICTION_PERM_PLACE_ORDER = 1 << 0;
+export const PREDICTION_PERM_CANCEL_ORDER = 1 << 1;
+export const PREDICTION_PERM_CLAIM = 1 << 2;
+export const PREDICTION_PERM_REQUEST_CLOSE = 1 << 3;
+export const PREDICTION_PERM_ALL = PREDICTION_PERM_PLACE_ORDER |
+    PREDICTION_PERM_CANCEL_ORDER |
+    PREDICTION_PERM_CLAIM |
+    PREDICTION_PERM_REQUEST_CLOSE;
+export const ACCOUNT_PERM_WITHDRAW = 1 << 0;
+export const ACCOUNT_PERM_MANAGE_DELEGATES = 1 << 1;
+export const ACCOUNT_PERM_RECEIVE = 1 << 2;
+export const ACCOUNT_PERM_ALL = 0xffffffff;
+export const PREDICTION_ERROR_CODES = {
+    EBadStatus: 1,
+    EMarketNotResolved: 3,
+    EAlreadyResolved: 4,
+    EBadPriceCap: 5,
+    EFillExceedsMax: 6,
+    EFillBelowMin: 7,
+    EBadExpiry: 8,
+    EBadPayment: 9,
+    EMarketPaused: 10,
+    EBelowMinReserve: 11,
+    EMarketAlreadyResolved: 12,
+    ECloseProceedsBelowMin: 13,
+    EUnauthorized: 14,
+    ENotAccountPosition: 16,
+    EOrderInCooldown: 17,
+    EOrderExpired: 18,
+    EOrderNotExpired: 19,
+};

package/dist/src/fetch.d.ts

@@ -0,0 +1,53 @@
+import type { PredictClient } from "./client.ts";
+import type { AccountDataView, CursorView, MarketIdInput, MarketView, OrderView, PositionView, RegistryView } from "./types.ts";
+export interface ViewBaseParams {
+    packageId?: string;
+    marketRegistry?: string;
+    accountRegistry?: string;
+    settlementCoinType?: string;
+}
+export declare function getRegistry(client: PredictClient, params?: ViewBaseParams): Promise<RegistryView>;
+export declare function getOrder(client: PredictClient, params: ViewBaseParams & {
+    orderId: bigint | number | string;
+}): Promise<OrderView>;
+export declare function getPosition(client: PredictClient, params: ViewBaseParams & {
+    positionId: bigint | number | string;
+}): Promise<PositionView>;
+export declare function getMarketById(client: PredictClient, params: ViewBaseParams & {
+    marketId: MarketIdInput;
+}): Promise<MarketView>;
+export declare function getMarketByKey(client: PredictClient, params: ViewBaseParams & {
+    marketKey: bigint | number | string;
+}): Promise<MarketView>;
+export declare function getOrderCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getPositionCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getUnresolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getResolvedMarketCursor(client: PredictClient, params?: ViewBaseParams): Promise<CursorView>;
+export declare function getAccountData(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+}): Promise<AccountDataView>;
+export declare function getAccountOrderIds(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketKey: bigint | number | string;
+}): Promise<bigint[]>;
+export declare function getAccountPositionIds(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketKey: bigint | number | string;
+}): Promise<bigint[]>;
+export declare function getAccountOrderIdsByMarketId(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketId: MarketIdInput;
+}): Promise<bigint[]>;
+export declare function getAccountPositionIdsByMarketId(client: PredictClient, params: ViewBaseParams & {
+    accountId: string;
+    marketId: MarketIdInput;
+}): Promise<bigint[]>;
+export declare function isKeeper(client: PredictClient, params: {
+    packageId?: string;
+    globalConfig?: string;
+    keeper: string;
+}): Promise<boolean>;
+export declare function getKeeperAddresses(client: PredictClient, params?: {
+    packageId?: string;
+    globalConfig?: string;
+}): Promise<string[]>;

package/dist/src/fetch.js

@@ -0,0 +1,187 @@
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { AccountDataViewBcs, MarketViewBcs, OrderViewBcs, PositionViewBcs, RegistryViewBcs, mapAccountDataView, mapCursorView, mapMarketView, mapOrderView, mapPositionView, mapRegistryView, } from "./bcs.js";
+import { marketIdArg, resolveAccountRegistry, resolveGlobalConfig, resolveMarketRegistry, resolvePackageId, resolveSettlementCoinType, toBigInt, } from "./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}]`);
+}
+export async function getRegistry(client, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::registry`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [tx.object(resolveMarketRegistry(client, params.marketRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return mapRegistryView(RegistryViewBcs.parse(extractReturnBytes(result)));
+}
+export async function getOrder(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::order`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.orderId)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return mapOrderView(OrderViewBcs.parse(extractReturnBytes(result)));
+}
+export async function getPosition(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::position`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.positionId)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return mapPositionView(PositionViewBcs.parse(extractReturnBytes(result)));
+}
+export async function getMarketById(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::market_by_id`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [tx.object(resolveMarketRegistry(client, params.marketRegistry)), marketIdArg(tx, params.marketId)],
+    });
+    const result = await client.simulate(tx);
+    return mapMarketView(MarketViewBcs.parse(extractReturnBytes(result)));
+}
+export async function getMarketByKey(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::market_by_key`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.pure.u64(toBigInt(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return mapMarketView(MarketViewBcs.parse(extractReturnBytes(result)));
+}
+async function readCursor(client, functionName, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::${functionName}`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [tx.object(resolveMarketRegistry(client, params.marketRegistry))],
+    });
+    const result = await client.simulate(tx);
+    return mapCursorView(bcs.u64().parse(extractReturnBytes(result, 0, 0)), bcs.option(bcs.u64()).parse(extractReturnBytes(result, 0, 1)), bcs.option(bcs.u64()).parse(extractReturnBytes(result, 0, 2)));
+}
+export function getOrderCursor(client, params = {}) {
+    return readCursor(client, "order_cursor", params);
+}
+export function getPositionCursor(client, params = {}) {
+    return readCursor(client, "position_cursor", params);
+}
+export function getUnresolvedMarketCursor(client, params = {}) {
+    return readCursor(client, "unresolved_market_cursor", params);
+}
+export function getResolvedMarketCursor(client, params = {}) {
+    return readCursor(client, "resolved_market_cursor", params);
+}
+export async function getAccountData(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::account`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return mapAccountDataView(AccountDataViewBcs.parse(extractReturnBytes(result)));
+}
+export async function getAccountOrderIds(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::account_order_ids`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            tx.pure.u64(toBigInt(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(bcs.u64()).parse(extractReturnBytes(result)).map((v) => BigInt(v));
+}
+export async function getAccountPositionIds(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::account_position_ids`,
+        arguments: [
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            tx.pure.u64(toBigInt(params.marketKey)),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(bcs.u64()).parse(extractReturnBytes(result)).map((v) => BigInt(v));
+}
+export async function getAccountOrderIdsByMarketId(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::account_order_ids_by_market_id`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            marketIdArg(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(bcs.u64()).parse(extractReturnBytes(result)).map((v) => BigInt(v));
+}
+export async function getAccountPositionIdsByMarketId(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::view::account_position_ids_by_market_id`,
+        typeArguments: [resolveSettlementCoinType(client, params.settlementCoinType)],
+        arguments: [
+            tx.object(resolveMarketRegistry(client, params.marketRegistry)),
+            tx.object(resolveAccountRegistry(client, params.accountRegistry)),
+            tx.pure.id(params.accountId),
+            marketIdArg(tx, params.marketId),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(bcs.u64()).parse(extractReturnBytes(result)).map((v) => BigInt(v));
+}
+export async function isKeeper(client, params) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::global_config::is_keeper`,
+        arguments: [
+            tx.object(resolveGlobalConfig(client, params.globalConfig)),
+            tx.pure.address(params.keeper),
+        ],
+    });
+    const result = await client.simulate(tx);
+    return bcs.bool().parse(extractReturnBytes(result));
+}
+export async function getKeeperAddresses(client, params = {}) {
+    const tx = new Transaction();
+    tx.moveCall({
+        target: `${resolvePackageId(client, params.packageId)}::global_config::keeper_addresses`,
+        arguments: [tx.object(resolveGlobalConfig(client, params.globalConfig))],
+    });
+    const result = await client.simulate(tx);
+    return bcs.vector(bcs.Address).parse(extractReturnBytes(result));
+}

package/dist/src/generated/bucket_v2_framework/account.d.ts

@@ -0,0 +1,100 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for Account Abstraction */
+import { MoveStruct, type RawTransactionArgument } from '../utils/index.ts';
+import { type Transaction } from '@mysten/sui/transactions';
+export declare const ACCOUNT: MoveStruct<any, any>;
+export declare const Account: MoveStruct<any, any>;
+export declare const AccountRequest: MoveStruct<any, any>;
+export interface NewArguments {
+    alias: RawTransactionArgument<string | null>;
+}
+export interface NewOptions {
+    package?: string;
+    arguments: NewArguments | [
+        alias: RawTransactionArgument<string | null>
+    ];
+}
+/** Public Funs */
+export declare function _new(options: NewOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function request(options?: RequestOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestWithAccountArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface RequestWithAccountOptions {
+    package?: string;
+    arguments: RequestWithAccountArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function requestWithAccount(options: RequestWithAccountOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface ReceiveArguments {
+    account: RawTransactionArgument<string>;
+    receiving: RawTransactionArgument<string>;
+}
+export interface ReceiveOptions {
+    package?: string;
+    arguments: ReceiveArguments | [
+        account: RawTransactionArgument<string>,
+        receiving: RawTransactionArgument<string>
+    ];
+    typeArguments: [
+        string
+    ];
+}
+export declare function receive(options: ReceiveOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface UpdateAliasArguments {
+    account: RawTransactionArgument<string>;
+    alias: RawTransactionArgument<string>;
+}
+export interface UpdateAliasOptions {
+    package?: string;
+    arguments: UpdateAliasArguments | [
+        account: RawTransactionArgument<string>,
+        alias: RawTransactionArgument<string>
+    ];
+}
+export declare function updateAlias(options: UpdateAliasOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface CreateArguments {
+    alias: RawTransactionArgument<string | null>;
+}
+export interface CreateOptions {
+    package?: string;
+    arguments: CreateArguments | [
+        alias: RawTransactionArgument<string | null>
+    ];
+}
+/** Entry Funs */
+export declare function create(options: CreateOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AccountAddressArguments {
+    account: RawTransactionArgument<string>;
+}
+export interface AccountAddressOptions {
+    package?: string;
+    arguments: AccountAddressArguments | [
+        account: RawTransactionArgument<string>
+    ];
+}
+export declare function accountAddress(options: AccountAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface RequestAddressArguments {
+    req: RawTransactionArgument<string>;
+}
+export interface RequestAddressOptions {
+    package?: string;
+    arguments: RequestAddressArguments | [
+        req: RawTransactionArgument<string>
+    ];
+}
+export declare function requestAddress(options: RequestAddressOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;
+export interface AliasLengthLimitOptions {
+    package?: string;
+    arguments?: [
+    ];
+}
+export declare function aliasLengthLimit(options?: AliasLengthLimitOptions): (tx: Transaction) => import("@mysten/sui/transactions").TransactionResult;