@waterx/sdk 2.1.0

package/dist/src/fetch.js

@@ -0,0 +1,419 @@
+/**
+ * Read-only queries built on top of `waterx_perp_view`.
+ *
+ * Each helper builds a one-shot PTB, runs `client.simulate(tx)`, and
+ * decodes the first command's return values into the matching generated
+ * BCS struct. The simulated sender is the zero address.
+ */
+import { fromBase64 } from "@mysten/bcs";
+import { bcs } from "@mysten/sui/bcs";
+import { Transaction } from "@mysten/sui/transactions";
+import { DRY_RUN_SENDER } from "./constants.js";
+import { burnFeeRate as burnFeeRateCall, creditSupply as creditSupplyCall, hasAsset as hasAssetCall, mintFeeRate as mintFeeRateCall, } from "./generated/native_custody/custody_vault.js";
+import { accountBalance as accountBalanceCall, accountIds as accountIdsCall, } from "./generated/waterx_account/account.js";
+import { AccountData, accountData as accountDataCall, getAccountOrders as getAccountOrdersCall, getAccountPositions as getAccountPositionsCall, getMarketOrders as getMarketOrdersCall, getMarketPositions as getMarketPositionsCall, getRedeemRequests as getRedeemRequestsCall, GlobalConfigData, globalConfigData as globalConfigDataCall, MarketData, marketData as marketDataCall, OrderData, orderData as orderDataCall, PoolData, poolData as poolDataCall, PositionData, positionData as positionDataCall, positionExists as positionExistsCall, RedeemRequestData, TokenPoolData, tokenPoolData as tokenPoolDataCall, } from "./generated/waterx_perp_view/view.js";
+// ============================================================================
+// Referral queries (waterx_referral::referral_table)
+// ============================================================================
+import { isValidReferralCode as isValidReferralCodeCall, referralCodeExists as referralCodeExistsCall, tryGetRefer as tryGetReferCall, } from "./generated/waterx_referral/referral_table.js";
+function toBytes(b) {
+    if (!b)
+        return undefined;
+    if (typeof b === "string")
+        return fromBase64(b);
+    // gRPC returns Uint8Array; JSON-RPC serialization may turn it into a
+    // numeric-indexed object. Normalize both.
+    if (b instanceof Uint8Array)
+        return b;
+    return new Uint8Array(Object.values(b));
+}
+async function simulateAndExtract(client, tx, commandIndex = 0, returnIndex = 0) {
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    if (sim.$kind === "FailedTransaction") {
+        const err = sim.FailedTransaction?.status?.error?.message ?? "FailedTransaction";
+        throw new Error(`simulate aborted: ${err}`);
+    }
+    const cmd = sim.commandResults?.[commandIndex];
+    const ret = cmd?.returnValues?.[returnIndex];
+    const bytes = toBytes(ret?.bcs) ?? toBytes(ret?.value?.bcs);
+    if (!bytes) {
+        throw new Error(`simulate returned no BCS value at commandResults[${commandIndex}].returnValues[${returnIndex}]`);
+    }
+    return bytes;
+}
+function withLp(client, lpType) {
+    return lpType ?? client.wlpType();
+}
+/**
+ * Look up the registered AccountData for a given wxa account ID.
+ * Returns `undefined` if the account has no perp data slot installed yet
+ * (the slot auto-installs on the first `add_position` / `add_order`).
+ * The underlying view fn returns `Option<AccountData>`.
+ */
+export async function getAccountData(client, accountId) {
+    const tx = new Transaction();
+    accountDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId,
+        },
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    const opt = bcs.option(AccountData).parse(bytes);
+    return opt ?? undefined;
+}
+export async function getMarketData(client, args) {
+    const tx = new Transaction();
+    marketDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return MarketData.parse(await simulateAndExtract(client, tx));
+}
+export async function getPoolData(client, args = {}) {
+    const tx = new Transaction();
+    poolDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { pool: tx.object(client.config.packages.wlp.wlp_pool) },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return PoolData.parse(await simulateAndExtract(client, tx));
+}
+export async function getTokenPoolData(client, args) {
+    const tx = new Transaction();
+    tokenPoolDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            tokenIndex: args.tokenIndex,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return TokenPoolData.parse(await simulateAndExtract(client, tx));
+}
+export async function getGlobalConfigData(client) {
+    const tx = new Transaction();
+    globalConfigDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: { cfg: tx.object(client.config.packages.waterx_perp.global_config) },
+    })(tx);
+    return GlobalConfigData.parse(await simulateAndExtract(client, tx));
+}
+export async function positionExists(client, args) {
+    const tx = new Transaction();
+    positionExistsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            positionId: args.positionId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return bcs.bool().parse(bytes);
+}
+export async function getPosition(client, args) {
+    const tx = new Transaction();
+    positionDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd,
+            positionId: args.positionId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return PositionData.parse(await simulateAndExtract(client, tx));
+}
+export async function getOrder(client, args) {
+    const tx = new Transaction();
+    orderDataCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd,
+            orderTypeTag: args.orderTypeTag,
+            triggerPrice: args.triggerPrice,
+            orderId: args.orderId,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return OrderData.parse(await simulateAndExtract(client, tx));
+}
+export async function getMarketOrders(client, args) {
+    const tx = new Transaction();
+    getMarketOrdersCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd ?? 0n,
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { orders: [] };
+    const ordersBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!ordersBytes)
+        return { orders: [] };
+    const ordersBuf = ordersBytes;
+    const orders = bcs.vector(OrderData).parse(ordersBuf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { orders, nextCursor };
+}
+export async function getMarketPositions(client, args) {
+    const tx = new Transaction();
+    getMarketPositionsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd ?? 0n,
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { positions: [] };
+    const positionsBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!positionsBytes)
+        return { positions: [] };
+    const buf = positionsBytes;
+    const positions = bcs.vector(PositionData).parse(buf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { positions, nextCursor };
+}
+export async function getAccountPositions(client, args) {
+    const tx = new Transaction();
+    getAccountPositionsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            wxaRegistry: tx.object(client.config.packages.waterx_account.account_registry),
+            basePriceUsd: args.basePriceUsd,
+            collateralPriceUsd: args.collateralPriceUsd ?? 0n,
+            accountObjectAddress: args.accountObjectAddress,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return bcs.vector(PositionData).parse(await simulateAndExtract(client, tx));
+}
+export async function getAccountOrders(client, args) {
+    const tx = new Transaction();
+    getAccountOrdersCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            marketRegistry: tx.object(client.config.packages.waterx_perp.market_registry_wlp),
+            ticker: args.ticker,
+            basePriceUsd: args.basePriceUsd ?? 0n,
+            accountObjectAddress: args.accountObjectAddress,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    return bcs.vector(OrderData).parse(await simulateAndExtract(client, tx));
+}
+export async function getRedeemRequests(client, args = {}) {
+    const tx = new Transaction();
+    getRedeemRequestsCall({
+        package: client.config.packages.waterx_perp_view.published_at,
+        arguments: {
+            pool: tx.object(client.config.packages.wlp.wlp_pool),
+            cursor: args.cursor ?? 0n,
+            pageSize: args.pageSize ?? 100n,
+        },
+        typeArguments: [withLp(client, args.lpType)],
+    })(tx);
+    tx.setSender(DRY_RUN_SENDER);
+    const sim = (await client.simulate(tx));
+    const ret = sim.commandResults?.[0]?.returnValues;
+    if (!ret)
+        return { requests: [] };
+    const reqBytes = toBytes(ret[0]?.bcs) ?? toBytes(ret[0]?.value?.bcs);
+    const cursorBytes = toBytes(ret[1]?.bcs) ?? toBytes(ret[1]?.value?.bcs);
+    if (!reqBytes)
+        return { requests: [] };
+    const buf = reqBytes;
+    const requests = bcs.vector(RedeemRequestData).parse(buf);
+    let nextCursor;
+    if (cursorBytes) {
+        const cb = cursorBytes;
+        const opt = bcs.option(bcs.u64()).parse(cb);
+        if (opt)
+            nextCursor = BigInt(opt);
+    }
+    return { requests, nextCursor };
+}
+function requireReferralPackage(client) {
+    const pkg = client.config.packages.waterx_referral?.published_at;
+    const table = client.config.packages.waterx_referral?.referral_table;
+    if (!pkg || !table) {
+        throw new Error("referral package not configured: set config.packages.waterx_referral.{published_at,referral_table}");
+    }
+    return { pkg, table };
+}
+/** Returns the referrer address bound to `referee`, or `undefined` if none. */
+export async function getRefererFor(client, referee) {
+    const { pkg, table } = requireReferralPackage(client);
+    const tx = new Transaction();
+    tryGetReferCall({
+        package: pkg,
+        arguments: { table: tx.object(table), referee },
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    const opt = bcs.option(bcs.Address).parse(bytes);
+    return opt ?? undefined;
+}
+/** True if `code` is a syntactically valid referral code (matches the contract's char rules). */
+export async function isValidReferralCode(client, code) {
+    const { pkg } = requireReferralPackage(client);
+    const tx = new Transaction();
+    isValidReferralCodeCall({ package: pkg, arguments: { code } })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return bcs.bool().parse(bytes);
+}
+/** True if `code` is already claimed in the on-chain ReferralTable. */
+export async function referralCodeExists(client, code) {
+    const { pkg, table } = requireReferralPackage(client);
+    const tx = new Transaction();
+    referralCodeExistsCall({
+        package: pkg,
+        arguments: { table: tx.object(table), code },
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return bcs.bool().parse(bytes);
+}
+// ============================================================================
+// wxa account reads (waterx_account — works on credit-only deployments,
+// which have no waterx_perp_view). Simulate `account::*` view functions.
+// ============================================================================
+/**
+ * List the wxa account IDs owned by `owner` (`account::account_ids`).
+ * Returns `[]` when the owner has never created an account. Use this to
+ * resolve the `account_id` a cross-chain deposit must target before
+ * filling the EVM `suiRecipient` field.
+ */
+export async function getAccountsByOwner(client, owner) {
+    const tx = new Transaction();
+    accountIdsCall({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            owner,
+        },
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return bcs.vector(bcs.Address).parse(bytes);
+}
+/**
+ * A wxa account's stored `Balance<T>` (`account::account_balance<T>`).
+ * `coinType` defaults to the deployment's CREDIT type — i.e. the bridged
+ * balance available to withdraw. Returns `0n` for an unknown coin type.
+ */
+export async function getAccountBalance(client, accountId, coinType) {
+    const tx = new Transaction();
+    accountBalanceCall({
+        package: client.config.packages.waterx_account.published_at,
+        arguments: {
+            registry: tx.object(client.config.packages.waterx_account.account_registry),
+            accountId,
+        },
+        typeArguments: [coinType ?? client.creditType()],
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return BigInt(bcs.u64().parse(bytes));
+}
+// ============================================================================
+// Native custody (custody_vault)
+// ============================================================================
+function requireCustody(client) {
+    const nc = client.config.packages.native_custody;
+    if (!nc?.vault) {
+        throw new Error("native_custody not configured — set config.packages.native_custody.vault");
+    }
+    return { pkg: nc.published_at, vault: nc.vault, creditType: client.creditType() };
+}
+/** Reads vault-wide native-custody state via `custody_vault::credit_supply`. */
+export async function getCustodyVaultData(client) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const tx = new Transaction();
+    creditSupplyCall({
+        package: pkg,
+        arguments: { vault: tx.object(vault) },
+        typeArguments: [creditType],
+    })(tx);
+    const bytes = await simulateAndExtract(client, tx);
+    return { creditSupply: BigInt(bcs.u64().parse(bytes)) };
+}
+/**
+ * Reads per-asset native-custody state for backing asset `assetType`.
+ *
+ * Fee rates are the vault's default config — queried with the zero address as
+ * caller, so no partner discount is applied — as 1e9-scaled `Float` values.
+ * When the asset is not registered, returns `registered: false` with `0n` rates.
+ *
+ * Note: the `SingleVault` balance / decimal / backing / min-burn / deprecated
+ * fields are not exposed here — the contract's getters for those return a
+ * `&SingleVault<T>` reference, which a PTB simulate cannot read.
+ */
+export async function getCustodyAssetData(client, assetType) {
+    const { pkg, vault, creditType } = requireCustody(client);
+    const typeArguments = [assetType, creditType];
+    const hasTx = new Transaction();
+    hasAssetCall({ package: pkg, arguments: { vault: hasTx.object(vault) }, typeArguments })(hasTx);
+    const registered = bcs.bool().parse(await simulateAndExtract(client, hasTx));
+    if (!registered)
+        return { registered: false, mintFeeRate: 0n, burnFeeRate: 0n };
+    const mintTx = new Transaction();
+    mintFeeRateCall({
+        package: pkg,
+        arguments: { vault: mintTx.object(vault), caller: DRY_RUN_SENDER },
+        typeArguments,
+    })(mintTx);
+    const mintFeeRate = BigInt(bcs.u128().parse(await simulateAndExtract(client, mintTx)));
+    const burnTx = new Transaction();
+    burnFeeRateCall({
+        package: pkg,
+        arguments: { vault: burnTx.object(vault), caller: DRY_RUN_SENDER },
+        typeArguments,
+    })(burnTx);
+    const burnFeeRate = BigInt(bcs.u128().parse(await simulateAndExtract(client, burnTx)));
+    return { registered: true, mintFeeRate, burnFeeRate };
+}

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

@@ -0,0 +1,107 @@
+/**************************************************************
+ * 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<{
+    dummy_field: import("@mysten/sui/bcs").BcsType<boolean, boolean, "bool">;
+}, "@bucket/framework::account::ACCOUNT">;
+export declare const Account: MoveStruct<{
+    id: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+    alias: import("@mysten/sui/bcs").BcsType<string | null, string | null | undefined, "Option<string>">;
+}, "@bucket/framework::account::Account">;
+export declare const AccountRequest: MoveStruct<{
+    account: import("@mysten/sui/bcs").BcsType<string, string | Uint8Array<ArrayBufferLike>, "bytes[32]">;
+}, "@bucket/framework::account::AccountRequest">;
+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;

package/dist/src/generated/bucket_v2_framework/account.js

@@ -0,0 +1,129 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Module for Account Abstraction */
+import { MoveStruct, normalizeMoveArguments } from "../utils/index.js";
+import { bcs } from '@mysten/sui/bcs';
+const $moduleName = '@bucket/framework::account';
+export const ACCOUNT = new MoveStruct({ name: `${$moduleName}::ACCOUNT`, fields: {
+        dummy_field: bcs.bool()
+    } });
+export const Account = new MoveStruct({ name: `${$moduleName}::Account`, fields: {
+        id: bcs.Address,
+        alias: bcs.option(bcs.string())
+    } });
+export const AccountRequest = new MoveStruct({ name: `${$moduleName}::AccountRequest`, fields: {
+        account: bcs.Address
+    } });
+/** Public Funs */
+export function _new(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        '0x1::option::Option<0x1::string::String>'
+    ];
+    const parameterNames = ["alias"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'new',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function request(options = {}) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request',
+    });
+}
+export function requestWithAccount(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_with_account',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function receive(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        null
+    ];
+    const parameterNames = ["account", "receiving"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'receive',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+        typeArguments: options.typeArguments
+    });
+}
+export function updateAlias(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null,
+        '0x1::string::String'
+    ];
+    const parameterNames = ["account", "alias"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'update_alias',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+/** Entry Funs */
+export function create(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        '0x1::option::Option<0x1::string::String>'
+    ];
+    const parameterNames = ["alias"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'create',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function accountAddress(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["account"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'account_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function requestAddress(options) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    const argumentsTypes = [
+        null
+    ];
+    const parameterNames = ["req"];
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'request_address',
+        arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    });
+}
+export function aliasLengthLimit(options = {}) {
+    const packageAddress = options.package ?? '@bucket/framework';
+    return (tx) => tx.moveCall({
+        package: packageAddress,
+        module: 'account',
+        function: 'alias_length_limit',
+    });
+}

package/dist/src/generated/bucket_v2_framework/deps/std/type_name.d.ts

@@ -0,0 +1,17 @@
+/**************************************************************
+ * THIS FILE IS GENERATED AND SHOULD NOT BE MANUALLY MODIFIED *
+ **************************************************************/
+/** Functionality for converting Move types into values. Use with care! */
+import { MoveStruct } from '../../../utils/index.ts';
+export declare const TypeName: MoveStruct<{
+    /**
+       * String representation of the type. All types are represented using their source
+       * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
+       * Struct types are represented as fully qualified type names; e.g.
+       * `00000000000000000000000000000001::string::String` or
+       * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+       * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+       * 32 depending on the Move platform)
+       */
+    name: import("@mysten/sui/bcs").BcsType<string, string, "string">;
+}, "std::type_name::TypeName">;