wowok_agent 1.6.6 → 2.1.8

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';