wowok_agent 1.6.6 → 2.1.9

package/dist/schema/call/treasury.js

@@ -0,0 +1,76 @@
+import { z } from "zod";
+import { TypedPermissionObjectSchema, CoinParamSchema, NamedObjectSchema, SubmissionCallSchema, CallEnvSchema } from "./base.js";
+import { AmountFromDepositGuardSchema, AmountFromWithdrawGuardSchema, PaymentInfoSchema } from "../query/index.js";
+import { AccountOrMark_AddressSchema, DescriptionSchema, ReceivedBalanceOrRecentlySchema, ReceivedObjectsOrRecentlySchema } from "../common/index.js";
+import { BalanceTypeSchema } from "../common/index.js";
+// Deposit 接口
+export const DepositSchema = z.object({
+    coin: CoinParamSchema.describe("Asset to deposit"),
+    by_external_deposit_guard: z.string().optional().describe("Deposit by verifying the specified Guard object ID or name; if not specified, deposit through Permission"),
+    payment_info: PaymentInfoSchema,
+    namedNewPayment: NamedObjectSchema.optional().describe("After deposit, create a new Payment object. You can specify a name for this object"),
+}).strict();
+// Withdraw 接口
+export const WithdrawSchema = z.object({
+    amount: z.union([
+        z.object({ fixed: BalanceTypeSchema
+        }).strict().describe("Fixed withdrawal amount, this method can only withdraw through Permission"),
+        z.object({ by_external_withdraw_guard: z.string().describe("Withdraw by verifying the specified Guard object ID or name (the amount is the value of the index number corresponding to the Guard object); if not specified, withdraw through Permission") }).strict(),
+    ]).describe("Withdrawal amount"),
+    recipient: AccountOrMark_AddressSchema.describe("ID or account to receive assets"),
+    payment_info: PaymentInfoSchema,
+    namedNewPayment: NamedObjectSchema.optional().describe("After withdrawal, create a new Payment object. You can specify a name for this object"),
+}).strict();
+// ExternalDepositGuard 操作类型
+export const ExternalDepositGuardSchema = z.discriminatedUnion("op", [
+    z.object({
+        op: z.literal("add"),
+        guards: z.array(AmountFromDepositGuardSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("set"),
+        guards: z.array(AmountFromDepositGuardSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("remove"),
+        guards: z.array(NamedObjectSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("clear"),
+    }).strict(),
+]);
+// ExternalWithdrawGuard 操作类型
+export const ExternalWithdrawGuardSchema = z.discriminatedUnion("op", [
+    z.object({
+        op: z.literal("add"),
+        guards: z.array(AmountFromWithdrawGuardSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("set"),
+        guards: z.array(AmountFromWithdrawGuardSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("remove"),
+        guards: z.array(NamedObjectSchema),
+    }).strict(),
+    z.object({
+        op: z.literal("clear"),
+    }).strict(),
+]);
+// CallTreasury_Data 接口
+export const CallTreasury_DataSchema = z.object({
+    object: TypedPermissionObjectSchema,
+    description: DescriptionSchema,
+    receive: ReceivedBalanceOrRecentlySchema.optional().describe("Receive CoinWrapper objects received by the object and deposit them into its balance."),
+    deposit: DepositSchema.optional().describe("Deposit to Treasury object"),
+    withdraw: WithdrawSchema.optional().describe("Withdraw from Treasury object"),
+    external_deposit_guard: ExternalDepositGuardSchema.optional().describe("Set external deposit Guard for Treasury object"),
+    external_withdraw_guard: ExternalWithdrawGuardSchema.optional().describe("Set external withdrawal Guard for Treasury object"),
+    owner_receive: ReceivedObjectsOrRecentlySchema.optional().describe("Unwrap CoinWrapper objects and other objects received by this object and send them to the owner of its Permission object."),
+    um: z.union([NamedObjectSchema, z.null()]).optional().describe("Contact object."),
+}).strict().describe("On-chain Treasury operations. USAGE: (1) CREATE NEW: Set 'object' field with {name, type, permission, ...} to create a Treasury. NOTE: 'name' goes INSIDE 'object', NOT at the data root level. 'permission' can be a new Permission object or reference an existing one - check 'object' field description for details. (2) OPERATE EXISTING: Set 'object' field with object ID or name. The 'object' field is CRITICAL and REQUIRED in both cases.");
+export const CallTreasury_InputSchema = z.object({
+    data: CallTreasury_DataSchema,
+    env: CallEnvSchema.optional(),
+    submission: SubmissionCallSchema.optional(),
+}).strict();

package/dist/schema/common/index.d.ts

@@ -0,0 +1,57 @@
+import { z } from "zod";
+export declare const DescriptionSchema: any;
+export declare const LongNameSchema: any;
+export declare const WowAddressSchema: any;
+export declare const TokenTypeSchema: any;
+export declare const TokenTypeWithDefaultSchema: any;
+export declare const NameSchema: any;
+export declare const NotEmptyNameSchema: any;
+export declare const NameOrAddressSchema: any;
+export declare const AccountOrMark_AddressSchema: any;
+export declare const ManyAccountOrMark_AddressSchema: any;
+export declare const ObjectOwnerSchema: any;
+export declare const ValueTypeUserSchema: any;
+export declare const ValueTypeSchema: any;
+export declare const ObjectTypeSchema: any;
+export declare const BalanceTypeSchema: any;
+export declare const QueryIdSchema: any;
+export declare const CacheExpireTypeSchema: any;
+export declare const ValueContainerSchema: z.ZodType<any>;
+export declare const SupportedValueUserSchema: any;
+export declare const SupportedValueSchema: any;
+export declare const GuardIdentifierSchema: any;
+export declare const GuardTableItemBaseSchema: any;
+export declare const GuardTableItemSchema: any;
+export declare const EntrypointSchema: any;
+export declare const FaucetNetworkSchema: any;
+export declare const ObjectBaseSchema: any;
+export declare const QueryEnvSchema: any;
+export declare const QueryReceivedSchema: any;
+export declare const ReceivedBalanceObjectSchema: any;
+export declare const ReceivedBalanceSchema: any;
+export declare const ReceivedBalanceOrRecentlySchema: any;
+export declare const ReceivedNormalSchema: any;
+export declare const ReceivedObjectsOrRecentlySchema: any;
+export declare const QueryReceivedResultSchema: any;
+export type WowAddress = z.infer<typeof WowAddressSchema>;
+export type TokenType = z.infer<typeof TokenTypeSchema>;
+export type Name = z.infer<typeof NameSchema>;
+export type NameOrAddress = z.infer<typeof NameOrAddressSchema>;
+export type AccountOrMark_Address = z.infer<typeof AccountOrMark_AddressSchema>;
+export type ManyAccountOrMark_Address = z.infer<typeof ManyAccountOrMark_AddressSchema>;
+export type ObjectOwner = z.infer<typeof ObjectOwnerSchema>;
+export type ValueType = z.infer<typeof ValueTypeSchema>;
+export type ObjectType = z.infer<typeof ObjectTypeSchema>;
+export type BalanceType = z.infer<typeof BalanceTypeSchema>;
+export type QueryId = z.infer<typeof QueryIdSchema>;
+export type CacheExpireType = z.infer<typeof CacheExpireTypeSchema>;
+export type SupportedValue = z.infer<typeof SupportedValueSchema>;
+export type GuardIdentifier = z.infer<typeof GuardIdentifierSchema>;
+export type GuardTableItem = z.infer<typeof GuardTableItemSchema>;
+export type Entrypoint = z.infer<typeof EntrypointSchema>;
+export type ObjectBase = z.infer<typeof ObjectBaseSchema>;
+export type QueryEnv = z.infer<typeof QueryEnvSchema>;
+export type QueryReceived = z.infer<typeof QueryReceivedSchema>;
+export type ReceivedBalance = z.infer<typeof ReceivedBalanceSchema>;
+export type ReceivedNormal = z.infer<typeof ReceivedNormalSchema>;
+export type QueryReceivedResult = z.infer<typeof QueryReceivedResultSchema>;

package/dist/schema/common/index.js

@@ -0,0 +1,331 @@
+import { z } from "zod";
+import { isValidAddress, ValueType as WowValueType, ObjectType as WowObjectType, ENTRYPOINT, isValidWowAddress, isValidName, isValidDescription, MAX_DESCRIPTION_LENGTH, isValidLongName, MAX_LONG_NAME_LENGTH } from "wowok";
+// ============================================================
+// Address Schema - Address format validation
+// ============================================================
+const isValidMoveIdentifier = (s) => {
+    if (s.length === 0)
+        return false;
+    const firstChar = s[0];
+    if (firstChar === '_') {
+        return s.length > 1 && /^[a-zA-Z0-9_]+$/.test(s.slice(1));
+    }
+    if (/^[a-zA-Z]$/.test(firstChar)) {
+        return /^[a-zA-Z0-9_]*$/.test(s.slice(1));
+    }
+    return false;
+};
+export const DescriptionSchema = z
+    .string()
+    .refine(isValidDescription, {
+    message: `Description string (max ${MAX_DESCRIPTION_LENGTH} bcs characters)`
+})
+    .describe(`Description string (max ${MAX_DESCRIPTION_LENGTH} bcs characters)`);
+export const LongNameSchema = z
+    .string()
+    .refine(isValidLongName, {
+    message: `max ${MAX_LONG_NAME_LENGTH} bcs characters`
+});
+export const WowAddressSchema = z
+    .string()
+    .refine(isValidAddress, {
+    //  or a builtin ID (0x5-0x9, @0xaaa, @0xaab, @0x403, @0xacc, @0xc)
+    message: "Invalid ID format: must be '0x' prefix followed by 64 hex characters"
+})
+    .describe("Valid ID: 0x prefix + 64 hex characters, or builtin ID (0x5-0x9, @0xaaa, @0xaab, @0x403, @0xacc, @0xc)");
+// ============================================================
+// TokenType Schema - Token type format validation
+// ============================================================
+const WOW_TOKEN_TYPE = "0x2::wow::WOW";
+export const TokenTypeSchema = z
+    .string()
+    .refine((val) => {
+    if (val === WOW_TOKEN_TYPE)
+        return true;
+    const parts = val.split("::");
+    if (parts.length !== 3)
+        return false;
+    const [address, module, structName] = parts;
+    if (!isValidWowAddress(address))
+        return false;
+    if (!isValidMoveIdentifier(module))
+        return false;
+    if (!isValidMoveIdentifier(structName))
+        return false;
+    return true;
+}, {
+    message: "Invalid token type format. Expected: {address}::{module}::{struct} where address is 0x+64hex, module/struct are valid Move identifiers, or '0x2::wow::WOW'"
+})
+    .describe("Token type in format: {address}::{module}::{struct}. Example: 0x2::wow::WOW");
+export const TokenTypeWithDefaultSchema = TokenTypeSchema
+    .default(WOW_TOKEN_TYPE)
+    .describe("Token type in format: {address}::{module}::{struct}. Default: 0x2::wow::WOW");
+// ============================================================
+// Name Schema - Name format validation
+// ============================================================
+export const NameSchema = z
+    .string()
+    .refine(isValidName, "Name string (max 64 bcs characters, must not start with '0x')");
+export const NotEmptyNameSchema = z.string().nonempty()
+    .refine(isValidName, "Name string (at least 1 character, max length 64 bcs characters)");
+// ============================================================
+// NameOrAddress Schema - Name or address
+// ============================================================
+export const NameOrAddressSchema = z
+    .string()
+    .refine((val) => {
+    if (isValidWowAddress(val))
+        return true;
+    if (isValidName(val))
+        return true;
+    return false;
+}, {
+    message: "Invalid ID format: must be '0x' prefix, or a builtin ID (0x5-0x9, @0xaaa, @0xaab, @0x403, @0xacc, @0xc)"
+}).describe("Account/Object name or ID. If specifying an account, use empty string '' for the default account. " +
+    "If it starts with '0x', it will be treated as an ID. " +
+    "Otherwise, it will be treated as a name (max 64 bcs characters).");
+// Define AccountOrMark_Address schema
+export const AccountOrMark_AddressSchema = z.object({
+    name_or_address: NameOrAddressSchema.optional(),
+    local_mark_first: z.boolean().optional().describe("Whether to prioritize local marks, if true, prioritize local marks, otherwise prioritize global marks"),
+}).strict().describe("Account or address lookup object. Use this to specify which account to use for an operation. " +
+    "EXAMPLE: { name_or_address: 'testor2' } - looks up account by name; " +
+    "EXAMPLE: { name_or_address: '0x1234...' } - uses address directly; " +
+    "If name_or_address is empty string '', uses the default local account.");
+// Define ManyAccountOrMark_Address schema
+export const ManyAccountOrMark_AddressSchema = z.object({
+    entities: z.array(AccountOrMark_AddressSchema),
+    check_all_founded: z.boolean().optional().describe("Whether to check all entities are found, if true, all entities must be found (abort and throw exception if any ID not found); if false, only return found IDs"),
+}).strict().describe("Used to batch find account or object IDs by name");
+// Define ObjectOwner schema
+export const ObjectOwnerSchema = z.union([
+    z.object({
+        AddressOwner: z.string().describe("Address owner"),
+    }).strict(),
+    z.object({
+        ObjectOwner: z.string().describe("Object owner"),
+    }).strict(),
+    z.object({
+        Shared: z.object({
+            initial_shared_version: z.union([z.string(), z.number()]).describe("Version when object became shared"),
+        }).strict().describe("Shared object"),
+    }).strict(),
+    z.literal("Immutable"),
+    z.object({
+        ConsensusAddressOwner: z.object({
+            owner: z.string().describe("Consensus ID owner"),
+            start_version: z.union([z.string(), z.number()]).describe("Version when object recently became consensus object"),
+        }).strict().describe("Consensus ID owner"),
+    }).strict(),
+]).describe("Object owner");
+// Define ValueType string names for user convenience
+const ValueTypeStringNames = [
+    "Bool", "Address", "String", "U8", "U16", "U32", "U64", "U128", "U256",
+    "VecBool", "VecAddress", "VecString", "VecU8", "VecU16", "VecU32", "VecU64", "VecU128", "VecU256", "VecVecU8"
+];
+// Define user available ValueType enum (supports both number and string)
+export const ValueTypeUserSchema = z.union([
+    z.literal(WowValueType.Bool).describe("Bool (0)"),
+    z.literal(WowValueType.Address).describe("Address (1)"),
+    z.literal(WowValueType.String).describe("String (2)"),
+    z.literal(WowValueType.U8).describe("U8 (3)"),
+    z.literal(WowValueType.U16).describe("U16 (4)"),
+    z.literal(WowValueType.U32).describe("U32 (5)"),
+    z.literal(WowValueType.U64).describe("U64 (6)"),
+    z.literal(WowValueType.U128).describe("U128 (7)"),
+    z.literal(WowValueType.U256).describe("U256 (8)"),
+    z.literal(WowValueType.VecBool).describe("VecBool (9)"),
+    z.literal(WowValueType.VecAddress).describe("VecAddress (10)"),
+    z.literal(WowValueType.VecString).describe("VecString (11)"),
+    z.literal(WowValueType.VecU8).describe("VecU8 (12)"),
+    z.literal(WowValueType.VecU16).describe("VecU16 (13)"),
+    z.literal(WowValueType.VecU32).describe("VecU32 (14)"),
+    z.literal(WowValueType.VecU64).describe("VecU64 (15)"),
+    z.literal(WowValueType.VecU128).describe("VecU128 (16)"),
+    z.literal(WowValueType.VecU256).describe("VecU256 (17)"),
+    z.literal(WowValueType.VecVecU8).describe("VecVecU8 (18)"),
+    // String representations (all case variants)
+    z.literal("Bool").describe("Bool"),
+    z.literal("Address").describe("Address"),
+    z.literal("String").describe("String"),
+    z.literal("U8").describe("U8"),
+    z.literal("U16").describe("U16"),
+    z.literal("U32").describe("U32"),
+    z.literal("U64").describe("U64"),
+    z.literal("U128").describe("U128"),
+    z.literal("U256").describe("U256"),
+    z.literal("VecBool").describe("VecBool"),
+    z.literal("VecAddress").describe("VecAddress"),
+    z.literal("VecString").describe("VecString"),
+    z.literal("VecU8").describe("VecU8"),
+    z.literal("VecU16").describe("VecU16"),
+    z.literal("VecU32").describe("VecU32"),
+    z.literal("VecU64").describe("VecU64"),
+    z.literal("VecU128").describe("VecU128"),
+    z.literal("VecU256").describe("VecU256"),
+    z.literal("VecVecU8").describe("VecVecU8"),
+    // Lowercase variants
+    z.literal("bool").describe("bool"),
+    z.literal("address").describe("address"),
+    z.literal("string").describe("string"),
+    z.literal("u8").describe("u8"),
+    z.literal("u16").describe("u16"),
+    z.literal("u32").describe("u32"),
+    z.literal("u64").describe("u64"),
+    z.literal("u128").describe("u128"),
+    z.literal("u256").describe("u256"),
+    z.literal("vecbool").describe("vecbool"),
+    z.literal("vecaddress").describe("vecaddress"),
+    z.literal("vecstring").describe("vecstring"),
+    z.literal("vecu8").describe("vecu8"),
+    z.literal("vecu16").describe("vecu16"),
+    z.literal("vecu32").describe("vecu32"),
+    z.literal("vecu64").describe("vecu64"),
+    z.literal("vecu128").describe("vecu128"),
+    z.literal("vecu256").describe("vecu256"),
+    z.literal("vecvecu8").describe("vecvecu8"),
+]).describe("User available value type (number or string, e.g., 6 or 'U64' or 'u64')");
+// Define ValueType enum (system use, includes Value)
+export const ValueTypeSchema = ValueTypeUserSchema.or(z.literal(WowValueType.Value).describe("Value (19)")).or(z.literal("Value").describe("Value"))
+    .describe("Value type (number or string, e.g., 6 or 'U64')");
+// Define ObjectType enum
+export const ObjectTypeSchema = z.enum([
+    WowObjectType.Permission,
+    WowObjectType.Repository,
+    WowObjectType.Arb,
+    WowObjectType.Arbitration,
+    WowObjectType.Service,
+    WowObjectType.Machine,
+    WowObjectType.Order,
+    WowObjectType.Progress,
+    WowObjectType.Payment,
+    WowObjectType.Treasury,
+    WowObjectType.Guard,
+    WowObjectType.Demand,
+    WowObjectType.Passport,
+    WowObjectType.Allocation,
+    WowObjectType.Resource,
+    WowObjectType.Reward,
+    WowObjectType.Discount,
+    WowObjectType.EntityRegistrar,
+    WowObjectType.EntityLinker,
+    WowObjectType.Proof,
+    WowObjectType.WReceivedObject,
+    WowObjectType.Contact,
+    WowObjectType.TableItem_ProgressHistory,
+    WowObjectType.TableItem_PermissionPerm,
+    WowObjectType.TableItem_DemandPresenter,
+    WowObjectType.TableItem_MachineNode,
+    WowObjectType.TableItem_TreasuryHistory,
+    WowObjectType.TableItem_RepositoryData,
+    WowObjectType.TableItem_RewardRecord,
+    WowObjectType.TableItem_EntityLinker,
+    WowObjectType.TableItem_AddressMark,
+    WowObjectType.TableItem_EntityRegistrar,
+]).describe("Wowok object type");
+// Define BalanceType schema
+export const BalanceTypeSchema = z.union([z.number(), z.string()]).describe("Balance type");
+// Define QueryIdSchema
+export const QueryIdSchema = z.number().int().min(0).describe("Query ID");
+// Define CacheExpireType schema
+export const CacheExpireTypeSchema = z.union([z.number(), z.literal("INFINITE")]).describe("Cache expiration time type");
+// Define ValueContainer schema
+export const ValueContainerSchema = z.lazy(() => z.object({
+    valueType: ValueTypeSchema.describe("Value type"),
+    value: SupportedValueSchema.describe("Value"),
+}).strict().describe("Value container with type and value"));
+// Define user available SupportedValue schema
+export const SupportedValueUserSchema = z.union([
+    z.boolean(),
+    z.union([AccountOrMark_AddressSchema, z.string()]),
+    z.string(),
+    z.number(),
+    z.array(z.boolean()),
+    z.union([ManyAccountOrMark_AddressSchema, z.array(z.string())]),
+    z.array(z.string()),
+    z.array(z.number()),
+    z.array(z.array(z.number())),
+]).describe("User available supported value type");
+// Define SupportedValue schema (system use, includes Value)
+export const SupportedValueSchema = SupportedValueUserSchema.or(ValueContainerSchema).describe("Supported value type");
+export const GuardIdentifierSchema = z.number().int().min(0).max(255).describe("Identifier (0-255) for data lookup in Guard table.");
+export const GuardTableItemBaseSchema = z.object({
+    identifier: GuardIdentifierSchema,
+    b_submission: z.boolean().describe("Whether user submission is required for this data"),
+    value_type: ValueTypeUserSchema.describe("Type of the value"),
+    value: SupportedValueUserSchema.optional().describe("The actual value data"),
+    name: z.string().default("").describe("Name or description of this data"),
+}).strict().describe("Guard table item");
+export const GuardTableItemSchema = GuardTableItemBaseSchema.extend({
+    object_type: ObjectTypeSchema.optional().describe("Object type when value_type is Address and represents a specific object"),
+}).strict().describe("Guard table item");
+// Define Entrypoint schema
+export const EntrypointSchema = z.enum([
+    ENTRYPOINT.Localnet,
+    ENTRYPOINT.Testnet,
+]).describe("Network entrypoint: Specifies which network the operation occurs on");
+export const FaucetNetworkSchema = z.enum([
+    ENTRYPOINT.Localnet,
+    ENTRYPOINT.Testnet,
+]).describe("Network entrypoint for Faucet: Specifies which network the operation occurs on");
+// Define ObjectBase schema
+export const ObjectBaseSchema = z.object({
+    object: z.string().describe("Object ID"),
+    type: ObjectTypeSchema.optional().describe("Object type"),
+    type_raw: z.string().optional().describe("Raw object type"),
+    owner: z.union([ObjectOwnerSchema, z.null()]).optional().describe("Object owner"),
+    version: z.string().optional().describe("Object version"),
+    previousTransaction: z.string().optional().describe("Previous transaction ID"),
+    cache_expire: CacheExpireTypeSchema.optional().describe("Cache expiration time"),
+    query_name: z.string().optional().describe("Original query name or address used to retrieve this object"),
+}).strict().describe("Object base information");
+// ================================================
+// Received related type definitions
+// ================================================
+// Define QueryEnv schema
+export const QueryEnvSchema = z.object({
+    no_cache: z.boolean().optional().describe("Whether to disable cache"),
+    network: EntrypointSchema.optional(),
+}).strict().describe("Query environment parameters");
+// Define QueryReceived schema
+export const QueryReceivedSchema = QueryEnvSchema.extend({
+    object: z.string().describe("Object ID to query"),
+    all_type: z.boolean().optional().describe("Whether to query all types of received objects"),
+    cursor: z.union([z.string(), z.null()]).optional().describe("Pagination cursor"),
+    limit: z.union([z.number(), z.null()]).optional().describe("Number of records returned per page"),
+}).strict().describe("Request parameters for querying object's received objects");
+// Define ReceivedBalanceObject schema
+export const ReceivedBalanceObjectSchema = z.object({
+    id: z.string().describe("Received CoinWrapper object ID"),
+    balance: BalanceTypeSchema,
+    payment: z.string().describe("Payment object ID"),
+}).strict().describe("Received CoinWrapper object record");
+// Define ReceivedBalance schema
+export const ReceivedBalanceSchema = z.object({
+    balance: BalanceTypeSchema,
+    token_type: TokenTypeSchema.describe("Asset type of Coin objects"),
+    received: z.array(ReceivedBalanceObjectSchema).describe("Received records of Coin objects"),
+}).strict().describe("Received record of Coin objects");
+// Define ReceivedBalanceOrRecently schema
+export const ReceivedBalanceOrRecentlySchema = z.union([
+    ReceivedBalanceSchema,
+    z.literal("recently")
+]).describe("Specified received balance record or all recently received balance record");
+// Define ReceivedNormal schema
+export const ReceivedNormalSchema = z.object({
+    id: z.string().nonempty().describe("Received object ID"),
+    type: z.string().nonempty().describe("Object type")
+}).strict().describe("Received normal object record");
+// Define ReceivedObjectsOrRecently schema
+export const ReceivedObjectsOrRecentlySchema = z.union([
+    z.array(ReceivedNormalSchema),
+    ReceivedBalanceSchema,
+    z.literal("recently"),
+]).describe("Specified received object records or all recently received object records");
+// Define QueryReceivedResult schema
+export const QueryReceivedResultSchema = z.object({
+    result: z.union([
+        ReceivedBalanceSchema,
+        z.array(ReceivedNormalSchema),
+    ]).describe("Received CoinWrapper object record or received other objects array")
+}).strict().describe("Query received result");

package/dist/schema/index.d.ts

@@ -0,0 +1,7 @@
+export * from './call/index.js';
+export * from './query/index.js';
+export * from './local/index.js';
+export * from './messenger/index.js';
+export * from './common/index.js';
+export * from './utils/guard-parser.js';
+export * from './utils/node-parser.js';

package/dist/schema/index.js

@@ -0,0 +1,8 @@
+// Package entry point
+export * from './call/index.js';
+export * from './query/index.js';
+export * from './local/index.js';
+export * from './messenger/index.js';
+export * from './common/index.js';
+export * from './utils/guard-parser.js';
+export * from './utils/node-parser.js';

package/dist/schema/local/index.d.ts

@@ -0,0 +1,120 @@
+import { z } from "zod";
+export declare const LocalMarkConstraints: {
+    readonly nameMaxLength: 64;
+    readonly tagMaxLength: 64;
+    readonly tagMaxCount: 50;
+};
+export declare const LocalInfoConstraints: {
+    readonly nameMaxLength: 64;
+    readonly contentMaxLength: 300;
+    readonly contentMaxCount: 50;
+    readonly defaultName: "Address of delivery";
+};
+export declare const AccountConstraints: {
+    readonly nameMaxLength: 64;
+};
+export declare const ErrorResultSchema: any;
+export declare const createResultSchema: <T extends z.ZodType>(successSchema: T) => any;
+export declare const CoinBalanceSchema: any;
+export declare const CoinStructSchema: any;
+export declare const PaginatedCoinsSchema: any;
+export declare const FaucetCoinInfoSchema: any;
+export declare const EventIdSchema: any;
+export declare const WowEventSchema: any;
+export declare const BalanceChangeSchema: any;
+export declare const GasCostSummarySchema: any;
+export declare const WowObjectRefSchema: any;
+export declare const OwnedObjectRefSchema: any;
+export declare const TransactionBlockEffectsModifiedAtVersionsSchema: any;
+export declare const WowMoveAbortSchema: any;
+export declare const ExecutionStatusSchema: any;
+export declare const WowGasDataSchema: any;
+export declare const WowTransactionBlockKindSchema: any;
+export declare const TransactionBlockDataSchema: any;
+export declare const WowTransactionBlockSchema: any;
+export declare const WowObjectChangeSchema: any;
+export declare const TransactionEffectsSchema: any;
+export declare const WowTransactionBlockResponseSchema: any;
+export declare const MarkParamSchema: any;
+export declare const MarkDataSchema: any;
+export declare const InfoDataInnerSchema: any;
+export declare const InfoDataSchema: any;
+export declare const LocalMarkFilterSchema: any;
+export declare const LocalInfoFilterSchema: any;
+export declare const QueryLocalInfoListSchema: any;
+export declare const QueryAccountSchema: any;
+export declare const QueryAccountResultSchema: any;
+export declare const AccountOperationSchema: any;
+export declare const AccountOperationResultSchema: any;
+export declare const LocalMarkOperationSchema: any;
+export declare const LocalMarkOperationResultSchema: any;
+export declare const LocalInfoOperationSchema: any;
+export declare const LocalInfoOperationResultSchema: any;
+export declare const FetchTokenInfoOperationSchema: any;
+export declare const QueryLocalMarkListSchema: any;
+export declare const QueryLocalMarkListResultSchema: any;
+export declare const AccountFilterSchema: any;
+export declare const QueryAccountListSchema: any;
+export declare const AccountDataSchema: any;
+export declare const QueryAccountListResultSchema: any;
+export declare const QueryLocalInfoListResultSchema: any;
+export declare const TokenTypeInfoSchema: any;
+export declare const TokenDataFilterSchema: any;
+export declare const QueryLocalTokenListResultSchema: any;
+export declare const AccountOperationOutputSchema: any;
+export declare const AccountOperationOutputWrappedSchema: any;
+export declare const LocalMarkOperationOutputSchema: any;
+export declare const LocalMarkOperationOutputWrappedSchema: any;
+export declare const LocalInfoOperationOutputSchema: any;
+export declare const LocalInfoOperationOutputWrappedSchema: any;
+export type CoinBalance = z.infer<typeof CoinBalanceSchema>;
+export type CoinStruct = z.infer<typeof CoinStructSchema>;
+export type PaginatedCoins = z.infer<typeof PaginatedCoinsSchema>;
+export type FaucetCoinInfo = z.infer<typeof FaucetCoinInfoSchema>;
+export type EventId = z.infer<typeof EventIdSchema>;
+export type WowEvent = z.infer<typeof WowEventSchema>;
+export type BalanceChange = z.infer<typeof BalanceChangeSchema>;
+export type GasCostSummary = z.infer<typeof GasCostSummarySchema>;
+export type WowObjectRef = z.infer<typeof WowObjectRefSchema>;
+export type OwnedObjectRef = z.infer<typeof OwnedObjectRefSchema>;
+export type TransactionBlockEffectsModifiedAtVersions = z.infer<typeof TransactionBlockEffectsModifiedAtVersionsSchema>;
+export type WowMoveAbort = z.infer<typeof WowTransactionBlockSchema>;
+export type ExecutionStatus = z.infer<typeof ExecutionStatusSchema>;
+export type WowGasData = z.infer<typeof WowGasDataSchema>;
+export type WowTransactionBlockKind = z.infer<typeof WowTransactionBlockKindSchema>;
+export type TransactionBlockData = z.infer<typeof TransactionBlockDataSchema>;
+export type WowTransactionBlock = z.infer<typeof WowTransactionBlockSchema>;
+export type WowObjectChange = z.infer<typeof WowObjectChangeSchema>;
+export type TransactionEffects = z.infer<typeof TransactionEffectsSchema>;
+export type WowTransactionBlockResponse = z.infer<typeof WowTransactionBlockSchema>;
+export type MarkParam = z.infer<typeof MarkParamSchema>;
+export type MarkData = z.infer<typeof MarkDataSchema>;
+export type InfoDataInner = z.infer<typeof InfoDataInnerSchema>;
+export type InfoData = z.infer<typeof InfoDataSchema>;
+export type QueryAccount = z.infer<typeof QueryAccountSchema>;
+export type QueryAccountResult = z.infer<typeof QueryAccountResultSchema>;
+export type AccountOperation = z.infer<typeof AccountOperationSchema>;
+export type AccountOperationResult = z.infer<typeof AccountOperationResultSchema>;
+export type LocalMarkOperation = z.infer<typeof LocalMarkOperationSchema>;
+export type LocalMarkOperationResult = z.infer<typeof LocalMarkOperationResultSchema>;
+export type LocalInfoOperation = z.infer<typeof LocalInfoOperationSchema>;
+export type FetchTokenInfoOperation = z.infer<typeof FetchTokenInfoOperationSchema>;
+export type LocalMarkFilter = z.infer<typeof LocalMarkFilterSchema>;
+export type LocalInfoFilter = z.infer<typeof LocalInfoFilterSchema>;
+export type AccountData = z.infer<typeof AccountDataSchema>;
+export type TokenTypeInfo = z.infer<typeof TokenTypeInfoSchema>;
+export type TokenDataFilter = z.infer<typeof TokenDataFilterSchema>;
+export type QueryLocalMarkListResult = z.infer<typeof QueryLocalMarkListResultSchema>;
+export type AccountFilter = z.infer<typeof AccountFilterSchema>;
+export type QueryAccountList = z.infer<typeof QueryAccountListSchema>;
+export type QueryAccountListResult = z.infer<typeof QueryAccountListResultSchema>;
+export type QueryLocalInfoList = z.infer<typeof QueryLocalInfoListSchema>;
+export type QueryLocalInfoListResult = z.infer<typeof QueryLocalInfoListResultSchema>;
+export type QueryLocalTokenListResult = z.infer<typeof QueryLocalTokenListResultSchema>;
+export type AccountOperationOutput = z.infer<typeof AccountOperationOutputSchema>;
+export type AccountOperationOutputWrapped = z.infer<typeof AccountOperationOutputWrappedSchema>;
+export type LocalMarkOperationOutput = z.infer<typeof LocalMarkOperationOutputSchema>;
+export type LocalMarkOperationOutputWrapped = z.infer<typeof LocalMarkOperationOutputWrappedSchema>;
+export type LocalInfoOperationOutput = z.infer<typeof LocalInfoOperationOutputSchema>;
+export type LocalInfoOperationOutputWrapped = z.infer<typeof LocalInfoOperationOutputWrappedSchema>;
+export * from "./wip.js";