wowok_agent/dist/schema/local.js

Agent for WoWok: Unlock Co-Creation, Lighting Transaction, Empower Potential.

import { z } from "zod";
import { BalanceOrCoin } from "../local/index.js";
import { LocalInfoNameDefault } from '../local/local.js';
import { zodToJsonSchema } from "zod-to-json-schema";
export const QueryAccountSchemaDescription = `Query local account information, including on-chain address, token balance, and list of token object addresses.`;
export const QueryAccountSchema = z.object({
    name_or_address: z.string().optional().describe("Your account name or address. undefined means default account."),
    balance_or_coin: z.nativeEnum(BalanceOrCoin).optional().describe("Query the balance or coin objects of the account."),
    token_type: z.string().optional().describe("Token type, default to 0x2::sui::SUI if not specified."),
});
export const AccountOperationSchemaDescription = `Account operations, including generating new accounts, setting default accounts, suspending/reactivating accounts, naming accounts, and transferring tokens between accounts.`;
export const AccountOperationSchema = z.object({
    gen: z.object({
        name: z.string().nonempty().optional().describe("Account name."),
        default: z.boolean().optional().describe("Whether to set the generated account as the default account."),
    }).optional().describe("Generate a new account."),
    default: z.object({
        name_or_address: z.string().nonempty().describe("The name or address of the account to set as the default account."),
    }).optional().describe("Set the default account."),
    suspend: z.object({
        name_or_address: z.string().optional().describe("The name or address of the account to suspend. undefined means default account."),
        suspend: z.boolean().optional().describe("Whether to suspend the account. If not specified, suspend the default account."),
    }).optional().describe("Suspend or reactivate the account."),
    name: z.object({
        new_name: z.string().nonempty().describe("The name to set for the account."),
        name_or_address: z.string().optional().describe("The name or address of the account to set the name for. undefined means default account."),
    }).optional().describe("Set the name of the account."),
    transfer: z.object({
        name_or_address_from: z.string().optional().describe("The name or address of the account to transfer from. undefined means default account."),
        name_or_address_to: z.string().optional().describe("The name or address of the account to transfer to. undefined means default account."),
        amount: z.union([z.string(), z.number()]).describe("The amount to transfer. Must be a positive integer."),
        token_type: z.string().optional().describe("Token type, default to 0x2::sui::SUI if not specified."),
    }).optional().describe("Transfer tokens from one account to another."),
});
export const AccountOperationSchemaInput = () => {
    return zodToJsonSchema(AccountOperationSchema);
};
export const LocalMarkOperationSchemaDescription = `Local mark operations facilitate efficient object address management by assigning names and tags to addresses, enabling faster querying and organization. 
Supported operations include adding/setting marks (with optional names and tags), removing specific tags, and removing all marks for addresses.`;
export const LocalMarkOperationSchema = z.object({
    data: z.union([
        z.object({ op: z.literal('removeall') }).describe("Remove all local marks."),
        z.object({ op: z.literal('add'), data: z.array(z.object({
                name: z.string().describe("The name of the mark."),
                address: z.string().describe("The address to mark."),
                tags: z.array(z.string()).optional().describe("The tags of the mark."),
                useAddressIfNameExist: z.boolean().optional().describe("Whether to use the address if the name already exists. Otherwise, use this name and change the original name to its address."),
            })) }).describe("Add or set local marks."),
        z.object({ op: z.literal('remove'), data: z.array(z.string().describe('The name of the mark')) }).describe("Remove local marks."),
    ])
});
export const LocalMarkOperationSchemaInput = () => {
    return zodToJsonSchema(LocalMarkOperationSchema);
};
export const LocalInfoOperationSchemaDescription = `Local info operations manage on-device storage of personal information (e.g., delivery addresses, phone numbers) for cryptographic processing and secure sharing with service providers. Supported operations include: adding info (requires name and content parameters), removing specific info entries by name, and updating existing entries with new content.`;
export const LocalInfoOperationSchema = z.object({
    data: z.union([
        z.object({
            op: z.literal('removeall')
        }).describe("Whether to remove all local info."),
        z.object({
            op: z.literal('add'),
            data: z.array(z.object({
                name: z.string().default(LocalInfoNameDefault).describe("The name of the local info."),
                content: z.string().describe("The content of the local info."),
                bdefault: z.boolean().optional().describe("Whether to set the content as default."),
            }))
        }).describe("Add local info."),
        z.object({
            op: z.literal('remove'),
            data: z.array(z.string().describe('The name of the local info.'))
        }).describe("Remove local info by name."),
    ])
});
export const LocalInfoOperationSchemaInput = () => {
    return zodToJsonSchema(LocalInfoOperationSchema);
};
export const QueryLocalMarkSchemaDescription = `Query local mark by name. Accepts a local mark name (string) as input, and returns an object containing: address (on-chain object address), name (assigned human-readable name), and tags (array of string tags). Local marks enable faster address management by mapping addresses to memorable names and categorized tags for efficient querying.`;
export const QueryLocalMarkSchema = z.object({
    name: z.string().describe("The name of the local mark."),
});
export const QueryLocalMarkSchemaInput = () => {
    return zodToJsonSchema(QueryLocalMarkSchema);
};
export const QueryLocalInfoSchemaDescription = `Query local info by name. Local info allows storing personal information (e.g. addresses, phone numbers) on-device, which can be cryptographically processed and shared with service providers.`;
export const QueryLocalInfoSchema = z.object({
    name: z.string().default(LocalInfoNameDefault).describe("The name of the local info."),
});
export const QueryLocalInfoSchemaInput = () => {
    return zodToJsonSchema(QueryLocalInfoSchema);
};
export const localMarkListDescription = 'List local marks. Local marks facilitate efficient object address management by assigning names and tags to addresses, enabling faster querying and organization.';
export const LocalMarkFilterSchemaDescription = `Filter local marks by optional criteria: name (string), tags (array of strings), or object address (string). Parameters can be used individually or in combination for precise queries. Returns an array of local mark objects, each containing: address (on-chain object address), name (human-readable name), and tags (categorical tags). Local marks enhance address management efficiency through flexible multi-condition filtering.`;
export const LocalMarkFilterSchema = z.object({
    name: z.string().optional().describe("The name of the local mark."),
    tags: z.array(z.string()).optional().describe("The tags of the local mark."),
    address: z.string().optional().describe("The object or address of the local mark."),
});
export const LocalInfoListSchemaDescription = `List local information entries. Local info enables on-device storage of personal data (e.g., addresses, phone numbers) structured as name-content pairs, supporting cryptographic processing and secure sharing with service providers.`;
export const LocalInfoListSchema = z.object({});
export const AccountListSchemaDescription = `List local accounts stored on the device. Accounts provide cryptographic signatures for on-chain operations and support management/operation of their owned on-chain objects and funds. If showSuspendedAccount is set to true (default: false), suspended accounts will be included in the result.`;
export const AccountListSchema = z.object({
    showSuspendedAccount: z.boolean().optional().default(false).describe("Whether to display suspended accounts."),
});
export const QueryLocalSchemaDescription = `Local schema for querying accounts, address names/tags, and personal information stored on the device. 
- **Accounts**: Manages local accounts used for signing on-chain transactions.
- **Address Marks**: Supports naming and tagging of addresses to enable object address retrieval by name.
- **Personal Information**: Stores private data (e.g., addresses, phone numbers) for on-chain usage.
Supports both collection-level queries (retrieving multiple entries) and individual item queries (fetching specific records).`;
export const QueryLocalSchema = z.object({
    query: z.union([
        z.object({ name: z.literal('account_list'), data: AccountListSchema }).describe(AccountListSchemaDescription),
        z.object({ name: z.literal('info_list'), data: LocalInfoListSchema }).describe(LocalInfoListSchemaDescription),
        z.object({ name: z.literal('mark_list'), data: LocalMarkFilterSchema }).describe(LocalMarkFilterSchemaDescription),
        z.object({ name: z.literal('account'), data: QueryAccountSchema }).describe(QueryAccountSchemaDescription),
        z.object({ name: z.literal('mark'), data: QueryLocalMarkSchema }).describe(QueryLocalMarkSchemaDescription),
        z.object({ name: z.literal('info'), data: QueryLocalInfoSchema }).describe(QueryLocalInfoSchemaDescription),
    ])
});
export const QueryLocalSchemaInput = () => {
    return zodToJsonSchema(QueryLocalSchema);
};
//# sourceMappingURL=local.js.map