wowok 1.5.56 → 1.6.59

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.5.56",
+  "version": "1.6.59",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -40,7 +40,8 @@
     "treasury",
     "payment",
     "arbitration",
-    "oracle"
+    "oracle",
+    "AI agent"
   ],
   "author": "wowok",
   "license": "Apache-2.0",

package/src/agent_call/agent_call.ts

@@ -0,0 +1,120 @@
+/**
+ * Provide a JSON call interface for AI
+ * 
+ */
+
+import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
+import { Protocol, } from '../protocol';
+import { Bcs, IsValidAddress, IsValidArgType, IsValidU64, parseObjectType, IsValidU8 } from '../utils'
+import { Errors, ERROR}  from '../exception'
+import { MultiGetObjectsParams } from '@mysten/sui/client';
+import { Permission, PermissionIndex } from '../permission';
+import { BCS } from '@mysten/bcs';
+import { PermissionAnswerItem, PermissionIndexType } from '../permission';
+import { Entity } from '../entity';
+import { Repository_Policy_Mode } from '../repository';
+export interface AgentFuncParameter {
+    type: 'string' | 'number' | 'boolean' | 'struct' ;
+    name: string;
+    description: string;
+    required: boolean;
+}
+
+export interface AgentFuncReturn {
+    type: 'string' | 'number' | 'boolean' | 'struct' ;
+    name: string;
+    description: string;
+}
+export interface AgentFunc {
+    name: string;
+    description: string;
+    module: string;
+    permissionIndex: number;
+    parameter: AgentFuncParameter[];
+    return?: AgentFuncReturn;
+}
+
+export const AGENT_FUNC: AgentFunc[] = [
+    {permissionIndex:PermissionIndex.repository, name:'Repository', description:'Launch new Repository', module: 'repository', parameter:[
+        {type:'string', name:'permission', description:'permission', required:true},
+        {type:'number', name:'mode', description:'mode', required:false}, 
+    ]},
+    {permissionIndex:PermissionIndex.repository_description, name:'Description', description:'Set Repository description', module: 'repository', parameter:[
+        {type:'string', name:'object', description:'object', required:true},
+        {type:'string', name:'description', description:'description', required:true},
+    ]},
+    {permissionIndex:PermissionIndex.repository_policy_mode, name:'Policy mode', description:'Set Repository policy mode', module: 'repository', parameter:[]},
+    {permissionIndex:PermissionIndex.repository_policies, name:'Policy', description:'Add/Remove/Edit Repository policy', module: 'repository', parameter:[]},
+    {permissionIndex:PermissionIndex.repository_policy_description, name:'Policy Description', description:'Set Repository policy description', module: 'repository', parameter:[]},
+    {permissionIndex:PermissionIndex.repository_policy_permission, name:'Policy Permission', description:'Set Repository policy permission',  module: 'repository', parameter:[]},
+    {permissionIndex:PermissionIndex.repository_reference, name:'Reference', description:'Set Repository reference', module: 'repository', parameter:[]},
+
+    {permissionIndex:PermissionIndex.service, name:'Service', description:'Launch new Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_description, name:'Description', description:'Set Service description', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_price, name:'Price', description:'Set Service item price', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_stock, name:'Inventory', description:'Set Service item inventory', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_payee, name:'Payee', description:'Set Service payee', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_repository, name:'Repository', description:'Set Service repositories', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_withdraw_guards, name:'Withdraw Guard', description:'Set Service withdraw guards', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_refund_guards, name:'Refund Guard', description:'Set Service refund guards', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_add_sales, name:'Add sales', description:'Add sale items for Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_remove_sales, name:'Remove sales', description:'Remove sale items for Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_discount_transfer, name:'Discount', description:'Launch discounts for Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_withdraw, name:'Withdraw', description:'Widthraw from Service orders', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_buyer_guard, name:'Buyer Guard', description:'Set Guard of buying for Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_machine, name:'Machine', description:'Set Machine for Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_endpoint, name:'Endpoint', description:'Set Service endpoint', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_publish, name:'Publish', description:'Allowing the creation of Order', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_clone, name:'Clone', description:'Clone Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_customer_required, name:'Buyer info', description:'Set Service buyer info required', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_pause, name:'Pause', description:'Pause/Unpause Service', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_treasury, name:'Treasury', description:'Externally withdrawable treasury for compensation or rewards', module: 'service', parameter:[]},
+    {permissionIndex:PermissionIndex.service_arbitration, name:'Arbitration', description:'Add/Remove arbitration that allows refunds from orders at any time based on arbitration results', module: 'service', parameter:[]},
+
+    {permissionIndex:PermissionIndex.demand, name:'Demand', description:'Launch new Demand', module: 'demand', parameter:[]},
+    {permissionIndex:PermissionIndex.demand_refund, name:'Refund', description:'Refund from Demand', module: 'demand', parameter:[]},
+    {permissionIndex:PermissionIndex.demand_expand_time, name:'Expand deadline', description:'Expand Demand deadline', module: 'demand', parameter:[]},
+    {permissionIndex:PermissionIndex.demand_guard, name:'Guard', description:'Set Demand guard', module: 'demand', parameter:[]},
+    {permissionIndex:PermissionIndex.demand_description, name:'Description', description:'Set Demand description', module: 'demand', parameter:[]},
+    {permissionIndex:PermissionIndex.demand_yes, name:'Yes', description:'Pick the Deamand serice', module: 'demand', parameter:[]},
+
+    {permissionIndex:PermissionIndex.machine, name: 'Machine', description:'Launch new Machine', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_description, name: 'Description', description:'Set Machine description', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_repository, name: 'Repository', description:'Set Machine repository', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_clone, name: 'Clone', description:'Clone Machine', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_node, name: 'Node', description:'Set Machine nodes', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_endpoint, name: 'Endpoint', description:'Set Machine endpoint', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_pause, name: 'Pause', description:'Pause/Unpause Machine', module: 'machine', parameter:[]},
+    {permissionIndex:PermissionIndex.machine_publish, name: 'Publish', description:'Allowing the creation of Progress', module: 'machine', parameter:[]},
+
+    {permissionIndex:PermissionIndex.progress, name: 'Progress', description:'Launch new Progress', module: 'progress', parameter:[]},
+    {permissionIndex:PermissionIndex.progress_namedOperator, name: 'Operator', description:'Set Progress operators', module: 'progress', parameter:[]},
+    {permissionIndex:PermissionIndex.progress_bind_task, name: 'Bind', description:'Set Progress task', module: 'progress', parameter:[]},
+    {permissionIndex:PermissionIndex.progress_context_repository, name: 'Repository', description:'Set Progress repository', module: 'progress', parameter:[]},
+    {permissionIndex:PermissionIndex.progress_unhold, name: 'Unhold', description:'Release Progress holdings', module: 'progress', parameter:[]},
+    {permissionIndex:PermissionIndex.progress_parent, name: 'Parent', description:'Set Progress parent', module: 'progress', parameter:[]},
+    
+    {permissionIndex:PermissionIndex.treasury, name: 'Treasury', description:'Launch new Treasury', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_deposit, name: 'Deposit', description:'Deposit coins', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_receive, name: 'Receive', description:'Receive coins from some address sent', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_withdraw, name: 'Withdraw', description:'Withdraw coins', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_withdraw_guard, name: 'Withdraw Guard', description:'Add/Remove Treasury withdraw guard', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_withdraw_mode, name: 'Withdraw mode', description:'Set Treasury withdraw mode', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_deposit_guard, name: 'Deposit Guard', description:'Set Treasury deposit guard', module: 'treasury', parameter:[]},
+    {permissionIndex:PermissionIndex.treasury_descritption, name: 'Description', description:'Set Treasury description', module: 'treasury', parameter:[]},
+
+    {permissionIndex:PermissionIndex.arbitration, name: 'Arbitration', description:'Launch new Arbitration', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_description, name: 'Description', description:'Set Arbitration description', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_endpoint, name: 'Endpoint', description:'Set Arbitration endpoint', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_fee, name: 'Fee', description:'Set Arbitration fee', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_guard, name: 'Guard', description:'Set Guard to apply for arbitration', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_arbitration, name: 'Arbitrate', description:'Determine the outcome of arbitration', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_pause, name: 'Pause', description:'Allowing/forbidding the creation of Arb', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_voting_guard, name: 'Voting Guard', description:'Add/Remove voting Guard', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_vote, name: 'Vote', description:'Vote on the application for arbitration', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_withdraw, name: 'Withdraw', description:'Withdraw the arbitration fee', module: 'arbitration', parameter:[]},
+    {permissionIndex:PermissionIndex.arbitration_treasury, name: 'Withdraw', description:'Set Treasury that fees was collected at the time of withdrawal', module: 'arbitration', parameter:[]},
+]
+export class AgentCall {
+    
+}

package/src/agent_query/entity.ts

@@ -0,0 +1,100 @@
+/**
+ * Provide a JSON query interface for AI
+ * 
+ */
+
+import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
+import { Protocol, } from '../protocol';
+import { Bcs, IsValidAddress } from '../utils'
+import { Errors, ERROR}  from '../exception'
+import { Entity } from '../entity';
+
+
+export interface EntityQuery {
+    address: string;
+    showTags?: boolean;
+    showMarks?: boolean;
+}
+
+export interface EntityDetail {
+    name: string;
+    description: string;
+    avatar: string;
+    x: string;
+    discord: string;
+    homepage: string;
+}
+
+export interface ObjectTag {
+    object: string;
+    nick_name: string;
+    tags: string[];
+}
+
+export interface ObjectMark {
+    mark_name: string;
+    objects: string[];
+}
+
+export interface EntityAnswer {
+    address: string; 
+    like: number;
+    dislike: number;
+    details: EntityDetail;
+    resource_object?: string;
+    lastActive_digest?: string; 
+    marks?: ObjectMark[];
+    tags?: ObjectTag[];
+}
+
+export class ENTITY_QUERY {
+    /*json: EntityQuery; return EntityAnswer */
+    static entity_json = async (json:string) : Promise<string> => {
+        try {
+            const q : EntityQuery = JSON.parse(json);
+            return JSON.stringify(await ENTITY_QUERY.entity(q));
+        } catch (e) {
+           return JSON.stringify({error:e}); 
+        }
+    }
+
+    static entity = async (query:EntityQuery) : Promise<EntityAnswer> => {
+        if (!IsValidAddress(query.address)) {
+            ERROR(Errors.IsValidAddress, 'entity.address')
+        }
+
+        const txb = new TransactionBlock();
+        Entity.From(txb).query_ent(query.address);
+
+        const res = await Protocol.Client().devInspectTransactionBlock({sender:query.address, transactionBlock:txb});
+        if (!res.results || res.results?.length !== 1 || res.results[0].returnValues?.length !== 1 )  {
+            ERROR(Errors.Fail, 'entity.fail')
+        }
+
+        const r1 = Bcs.getInstance().de_ent(Uint8Array.from(res!.results![0].returnValues![0][0]));
+        const a = Bcs.getInstance().de_entInfo(Uint8Array.from(r1.avatar));
+        var ret : EntityAnswer = {address:query.address, like:r1.like, dislike:r1.dislike, resource_object:r1.resource?.some ?? undefined,
+            details:{homepage:a.homepage, name:a.name, avatar:a.avatar, x:a.twitter, discord:a.discord, description:a.description}, 
+            }; 
+
+        if (r1.resource?.some && query.showTags) {
+            const res2 = await Protocol.Client().getObject({id:r1.resource?.some, options:{showContent:true, showPreviousTransaction:true, showType:true}});
+            ret.tags = (res2?.data?.content as any)?.fields?.tags?.map((v:any) => {
+                return {address:v.fields.object, nick:v.fields.nick, tags:v.fields.tags}
+            })
+            
+            ret.lastActive_digest = res2.data?.previousTransaction ?? '';
+        }
+
+        if (r1.resource?.some && query.showMarks) {
+            const fields = await Protocol.Client().getDynamicFields({parentId:r1.resource?.some});
+            if (fields.data.length > 0) {
+                const objects = await Protocol.Client().multiGetObjects({ids:fields.data.map(v => v.objectId), options:{showContent:true}});
+                ret.marks = objects.map((i:any) => {
+                    return {mark_name:i.data.content.fields.name, objects:i.data.content.fields.value}
+                })
+            }
+        }
+        return ret
+    }
+}

package/src/agent_query/object.ts

@@ -0,0 +1,518 @@
+/**
+ * Provide a JSON query interface for AI
+ * 
+ */
+
+import { Protocol } from '../protocol';
+import { Treasury_WithdrawMode, Treasury_Operation } from '../treasury';
+import { Repository_Type, Repository_Policy_Mode, Repository_Policy } from '../repository';
+import { Service_Discount_Type, Service_Sale } from '../service';
+import { Machine_Node, Machine } from '../machine';
+import { Progress, History } from '../progress';
+export interface ObjectBase {
+    object: string;
+    type?: string;
+    type_raw?: string;
+    owner?: any;
+    version?: string;
+}
+export interface ObjectPermission extends ObjectBase {
+    builder: string;
+    admin: string[];
+    description: string;
+    entity_count: number;
+    biz_permission: {id:number; name:string}[];
+}
+
+export interface PermissionTable_Entity extends ObjectBase {
+    entity: string;
+    permission: {id:number; guard?:string|null}[];
+}
+
+export interface ObjectDemand extends ObjectBase {
+    permission: string;
+    guard?: {object:string; service_id_in_guard?:number|null} | null;
+    description: string;
+    time_expire: string;
+    yes?: string | null;
+    presenter_count: number;
+    bounty: {object:string; balance:string; type:string}[];
+}
+
+export interface DemandTable_Presenter extends ObjectBase {
+    service: string;
+    presenter: string;
+    recommendation: string;
+}
+
+export interface ObjectMachine extends ObjectBase {
+    permission: string;
+    bPaused: boolean;
+    bPublished: boolean;
+    consensus_repository: string[];
+    description: string;
+    endpoint?: string | null;
+    node_count: number;
+}
+
+export interface MachineTable_Node extends ObjectBase {
+    node: Machine_Node;
+}
+
+export interface ObjectProgressHolder {
+    forward_name: string;
+    holder?: string | null;
+    orders: string[];
+    msg: string;
+    accomplished: boolean;
+    time: string;
+}
+
+export interface ObjectProgressSession {
+    forward: ObjectProgressHolder[];
+    weights: number;
+    threshold: number;
+    next_node: string;
+}
+
+export interface ObjectProgress extends ObjectBase {
+    machine: string;
+    current: string;
+    context_repository?: string | null;
+    parent?: string | null;
+    task?: string | null;
+    session: ObjectProgressSession[];
+    history_count: number;
+    namedOperator: {name:string, operator:string[]}[];
+}
+
+export interface ProgressTable_History extends ObjectBase {
+    history: History;
+}
+
+export interface ObjectService extends ObjectBase {
+    permission: string;
+    bPaused: boolean;
+    bPublished: boolean;
+    description: string;
+    arbitration: string[];
+    buy_guard?: string | null;
+    endpoint?: string | null;
+    extern_withdraw_treasuries: string[];
+    machine?: string | null;
+    payee: string;
+    repository: string[];
+    sales_count: number;
+    withdraw_guard: {guard:string, percent:number}[];
+    refund_guard: {guard:string, percent:number}[];
+    customer_required_info?: {pubkey:string; required_info:string[]};
+}
+
+export interface ServiceTable_Sale extends ObjectBase {
+    item: Service_Sale;
+}
+export interface ObjectOrder extends ObjectBase {
+    service: string;
+    amount: string;
+    balance: string;
+    payer: string;
+    arb: string[];
+    agent: string[];
+    progress?: string | null;
+    discount?: string | null;
+    required_info?: {pubkey:string; msg_encrypted:string};
+    item: Service_Sale[];
+}
+
+export interface ObjectTreasury extends ObjectBase {
+    permission: string;
+    description: string;
+    inflow: string;
+    outflow: string;
+    withdraw_mode: Treasury_WithdrawMode;
+    withdraw_guard: {guard:string, percent:number}[];
+    deposit_guard?: string | null;
+    balance: string;
+    history_count: number;
+}
+export interface TreasuryTable_History extends ObjectBase {
+    id: number,
+    operation: Treasury_Operation,
+    signer: string,
+    payment: string,
+    amount: string,
+    time: string,
+}
+export interface ObjectArbitration extends ObjectBase {
+    permission: string;
+    description: string;
+    bPaused: boolean;
+    endpoint?: string | null;
+    fee: string;
+    fee_treasury: string;
+    usage_guard?: string | null;
+    voting_guard: {guard:string, weights:number}[];
+}
+
+export interface ObjectArb extends ObjectBase {
+    arbitration: string;
+    order: string;
+    description: string;
+    bWithdrawn: boolean;
+    fee: string;
+    feedback: string;
+    indemnity?: string | null;
+    proposition: {proposition:string, votes:string};
+    voted_count: number;
+}
+export interface ArbTable_Vote extends ObjectBase {
+    singer: string;
+    vote: number[];
+    weight: string;
+    time: string;
+}
+export interface ObjectRepository extends ObjectBase {
+    permission: string;
+    description: string;
+    policy_mode: Repository_Policy_Mode;
+    rep_type: Repository_Type;
+    reference: string[];
+    policy: Repository_Policy[];
+    data_count: number;
+}
+export interface RepositoryTable_Data extends ObjectBase {
+    address: string;
+    key: string;
+    data: Uint8Array;
+}
+export interface ObjectPayment extends ObjectBase {
+    amount: string;
+    for_guard?: string | null;
+    for_object?: string | null;
+    from ?: string | null;
+    biz_id: string;
+    remark: string;
+    signer: string;
+    time: string;
+    record: {recipient:string; amount:string}[];
+}
+export interface ObjectDiscount extends ObjectBase {
+    service: string;
+    name: string;
+    off_type: Service_Discount_Type;
+    price_greater?: string | null;
+    off: string;
+    time_start: string;
+    time_end: string;
+}
+
+export interface ObjectGuard extends ObjectBase {
+    description: string;
+    input: Uint8Array;
+    identifier: {id:number; bWitness:boolean; value:Uint8Array}[];
+}
+
+export interface ObjectsQuery {
+    objects: string[];
+    showType?: boolean;
+    showContent?: boolean;
+    showOwner?: boolean;
+}
+
+export interface ObjectsAnswer {
+    objects?: ObjectBase[];
+    error?: string;
+}
+
+export interface TableQuery {
+    parent: string;
+    cursor?: string | null | undefined;
+    limit?: number | null | undefined;
+}
+
+export interface TableAnswer {
+    items: TableItem[];
+    nextCursor: string | null;
+    hasNextPage: boolean;
+}
+
+export interface TableItemQuery {
+    parent: string;
+    name: {type:string; value:string};
+}
+export interface TableItemAnwser {
+    object: string;
+    type?: string;
+    version?: string;
+    owner?: any;
+}
+
+export interface TableItem {
+    name: {type:string; value:string};
+    object: string;
+    version: string;
+    error?: string;
+}
+
+export const PermissionTable_Type = 'address';
+
+export class OBJECT_QUERY {
+    /* json: ObjectsQuery string */
+    static objects_json = async (json:string) : Promise<string> => {
+        try {
+            const q : ObjectsQuery = JSON.parse(json);
+            return JSON.stringify(await OBJECT_QUERY.objects(q));
+        } catch (e) {
+            return JSON.stringify({error:e?.toString()})
+        }
+    }
+
+    /* json: TableQuery string */
+    static table_json = async (json:string) : Promise<string> => {
+        try {
+            const q : TableQuery = JSON.parse(json);
+            return JSON.stringify(await OBJECT_QUERY.table(q));
+        } catch (e) {
+            return JSON.stringify({error:e?.toString()})
+        }
+    }
+
+    /* json: TableQuery string*/
+    static tableItem_json = async (json:string) : Promise<string> => {
+        try {
+            const q : TableItemQuery = JSON.parse(json);
+            return JSON.stringify(await OBJECT_QUERY.tableItem(q));
+        } catch (e) {
+            return JSON.stringify({error:e?.toString()})
+        }
+    }
+
+    static objects = async (query: ObjectsQuery) : Promise<ObjectsAnswer> => {
+        if (query.objects.length > 0) {
+            const res = await Protocol.Client().multiGetObjects({ids:query.objects, 
+                options:{showContent:query.showContent, showType:query.showType, showOwner:query.showOwner}});
+            console.log(JSON.stringify(res))
+            return {objects:res.map(v=>this.data2object(v?.data))}                
+        } 
+        return {objects:[]}
+    }
+
+    static table = async (query:TableQuery) : Promise<TableAnswer> => {
+        const res = await Protocol.Client().getDynamicFields({parentId:query.parent, cursor:query.cursor, limit:query.limit});
+        return {items:res?.data?.map(v=>{
+            return {object:v.objectId, type:v.type, version:v.version, name:{
+                type:v.name.type, value:v.name.value?.toString() ?? ''
+            }} 
+        }), nextCursor:res.nextCursor, hasNextPage:res.hasNextPage}
+    }
+    
+    static tableItem = async (query:TableItemQuery) : Promise<TableItemAnwser> => {
+        const res = await Protocol.Client().getDynamicFieldObject({parentId:query.parent, name:{type:query.name.type, value:query.name.value}});
+        return {object:res.data?.objectId ??'', version:res.data?.version, owner:res.data?.owner}
+    }
+
+    private static data2object = (data?:any) : ObjectBase => {
+        const content = (data?.content as any)?.fields;
+        const id = data?.objectId ?? (content?.id?.id ?? undefined);
+        const type_raw:string | undefined = data?.type ?? (data?.content?.type ?? undefined);
+        const version = data?.version ?? undefined;
+        const owner = data?.owner ?? undefined;
+        const type:string | undefined = type_raw ? Protocol.Instance().object_name_from_type_repr(type_raw) : undefined;
+
+        if (type) {
+            switch(type) {
+            case 'Permission':
+                return {object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    builder: content?.builder ??'', admin:content?.admin, description:content?.description??'',
+                    entity_count: parseInt(content?.table?.fields?.size), 
+                    biz_permission:content?.user_define?.fields?.contents?.map((v:any) => {
+                        return {id:parseInt(v?.fields?.key), name:v?.fields?.value}
+                    })
+                } as ObjectPermission;
+            case 'Demand':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    permission: content?.permission, description:content?.description,
+                    guard:content?.guard ? {object:content?.guard, service_id_in_guard:content?.service_identifier}:undefined,
+                    time_expire:content?.time_expire, yes:content?.yes, 
+                    presenter_count:parseInt(content?.presenters?.fields?.size),
+                    bounty: content?.bounty?.map((v:any) => {
+                        return {type:v?.fields?.type, object:v?.fields?.id?.id, balance:v?.fields?.balance}
+                    })
+                } as ObjectDemand;
+            case 'Machine':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    permission: content?.permission ?? '', description:content?.description??'',
+                    bPaused: content?.bPaused, bPublished:content?.bPublished, endpoint:content?.endpoint,
+                    consensus_repository:content?.consensus_repositories, node_count:parseInt(content?.nodes?.fields?.size),
+                } as ObjectMachine;
+            case 'Progress':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    machine: content?.machine, current: content?.current, task:content?.task,
+                    parent:content?.parent,  history_count:parseInt(content?.history?.fields?.contents?.fields?.size),
+                    namedOperator:content?.namedOperator?.fields?.contents?.map((v:any) => {
+                        return {name:v?.fields?.key, operator:v?.fields?.value}
+                    }),
+                    session:content?.session?.fields?.contents?.map((v:any) => {
+                        return {weights:v?.fields?.value?.fields?.weight, threshold:v?.fields?.value?.fields?.threshold,
+                            next_node:v?.fields?.key, forward: v?.fields?.value?.fields?.forwards?.fields?.contents?.map((i:any) => {
+                                return {forward_name:i?.fields?.key, accomplished:i?.fields?.value?.fields?.accomplished,
+                                    msg:i?.fields?.value?.fields?.msg, orders:i?.fields?.value?.fields?.orders, 
+                                    time:i?.fields?.value?.fields?.time, holder:i?.fields?.value?.fields?.who
+                                }
+                            })
+                        }
+                    })
+                } as ObjectProgress;
+            case 'Order':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    service:content?.service, amount: content?.amount, agent:content?.agent, arb:content?.dispute, 
+                    payer:content?.payer, progress:content?.progress, discount:content?.discount, balance:content?.payed,
+                    required_info: content?.required_info ? 
+                        {pubkey:content?.required_info?.fields?.customer_pub, msg_encrypted:content?.required_info?.fields?.info} 
+                        : undefined,
+                    item : content?.items?.map((v:any) => {
+                        return {name:v?.fields?.name, price:v?.fields?.price, stock:v?.fields?.stock, endpoint:v?.fields?.endpoint}
+                    }),
+                } as ObjectOrder;
+            case 'Service':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    machine:content?.machine, permission:content?.permission, description:content?.description,
+                    arbitration:content?.arbitrations, bPaused:content?.bPaused, bPublished:content?.bPublished,
+                    buy_guard:content?.buy_guard, endpoint:content?.endpoint, payee:content?.payee, repository:content?.repositories, 
+                    withdraw_guard:content?.withdraw_guard?.fields?.contents?.map((v:any) => {
+                        return {object:v?.fields?.key, percent:v?.fields?.value}
+                    }),
+                    refund_guard:content?.refund_guard?.fields?.contents?.map((v:any) => {
+                        return {object:v?.fields?.key, percent:v?.fields?.value}
+                    }),
+                    sales_count:parseInt(content?.sales?.fields?.size), extern_withdraw_treasuries:content?.extern_withdraw_treasuries,
+                    customer_required_info:content?.customer_required ? 
+                        {pubkey:content?.customer_required?.fields?.service_pubkey, required_info:content?.customer_required?.fields?.customer_required_info}
+                        :undefined,
+                } as ObjectService;
+            case 'Treasury':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    permission:content?.permission, description:content?.description, withdraw_mode:content?.withdraw_mode,
+                    history_count:parseInt(content?.history?.fields?.contents?.fields?.size), balance: content?.balance, 
+                    deposit_guard:content?.deposit_guard, withdraw_guard:content?.withdraw_guard?.fields?.contents?.map((v:any) => {
+                        return {object:v?.fields?.key, percent:v?.fields?.value}
+                    })
+                } as ObjectTreasury;
+            case 'Arbitration':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    permission:content?.permission, description:content?.description, fee:content?.fee,
+                    fee_treasury:content?.fee_treasury, usage_guard:content?.usage_guard,
+                    endpoint:content?.endpoint, bPaused:content?.bPaused, voting_guard:content?.voting_guard?.fields?.contents?.map((v:any) => {
+                        return {object:v?.fields?.key, weights:v?.fields?.value}
+                    }) 
+                } as ObjectArbitration;  
+            case 'Arb':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    arbitration:content?.arbitration, description:content?.description, fee:content?.fee,
+                    feedback:content?.feedback, indemnity:content?.indemnity, order:content?.order,
+                    voted_count:parseInt(content?.voted?.fields?.size), 
+                    proposition:content?.proposition?.fields?.contents?.map((v:any) => {
+                        return {proposition:v?.fields?.key, votes:v?.fields?.value}
+                    }) 
+                } as ObjectArb;  
+            case 'Repository':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    permission:content?.permission, description:content?.description, policy_mode:content?.policy_mode,
+                    data_count:parseInt(content?.data?.fields?.size), reference:content?.reference, rep_type:content?.type, 
+                    policy:content?.policies?.fields?.contents?.map((v:any) => {
+                        return {key:v?.fields?.key, description:v?.fields?.value?.fields?.description, 
+                          permissionIndex:v?.fields?.value?.fields?.permission_index, dataType:v?.fields?.value?.fields?.value_type}
+                      })
+                } as ObjectRepository;  
+            case 'Payment':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    signer:content?.signer, time:content?.time, remark:content?.remark, from: content?.from,
+                    biz_id:content?.index, for_guard:content?.for_guard, for_object:content?.for_object,
+                    amount:content?.amount, record:content?.record?.map((v:any) => {
+                        return {recipient:v?.fields?.recipient, amount:v?.fields?.amount}
+                    })
+                } as ObjectPayment;  
+            case 'Discount':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    service:content?.service, time_start:content?.time_start, time_end:content?.time_end, 
+                    price_greater:content?.price_greater, off_type:content?.type, off:content?.off,
+                    name:content?.name
+                } as ObjectDiscount;   
+            case 'Guard':
+                return {
+                    object:id, type:type, type_raw:type_raw, owner:owner, version:version,
+                    description:content?.description, input:Uint8Array.from(content?.input?.fields?.bytes),
+                    identifier:content?.constants?.map((v:any) => {
+                        return {id:v?.fields?.identifier, bWitness:v?.fields?.bWitness, value:Uint8Array.from(v?.fields?.value)}
+                    })
+                } as ObjectGuard;   
+            }
+        } 
+        
+        const start = type_raw?.indexOf('0x2::dynamic_field::Field<');
+        if (start === 0) {
+            const end = type_raw?.substring('0x2::dynamic_field::Field<'.length);
+            if(end && Protocol.Instance().hasPackage(end)) {
+                if (end.includes('::demand::Tips>')) {
+                    return {
+                        object:id, type:'DemandTable_Presenter', type_raw:type_raw, owner:owner, version:version,
+                        service:content?.name, presenter:content?.value?.fields?.who, recommendation:content?.value?.fields?.tips
+                    } as DemandTable_Presenter;
+                } else if (end.includes('::machine::NodePair>>>')) {
+                    return {
+                        object:id, type:'MachineTable_Node', type_raw:type_raw, owner:owner, version:version,
+                        node:{name:content?.name, pairs:Machine.rpc_de_pair(content?.value)}
+                    } as MachineTable_Node;
+                } else if (end.includes('::progress::History>')) {
+                    return {
+                        object:id, type:'ProgressTable_History', type_raw:type_raw, owner:owner, version:version,
+                        history:Progress.rpc_de_history(content)
+                    } as ProgressTable_History;
+                } else if (end.includes('::service::Sale>')) {
+                    return {
+                        object:id, type:'ServiceTable_Sale', type_raw:type_raw, owner:owner, version:version,
+                        item:{item:content?.name, stock:content?.value?.fields?.stock, price:content?.value?.fields?.price,
+                            endpoint:content?.value?.fields?.endpoint
+                        }
+                    } as ServiceTable_Sale;
+                } else if (end.includes('::treasury::Record>')) {
+                    return {
+                        object:id, type:'TreasuryTable_History', type_raw:type_raw, owner:owner, version:version,
+                        id: content?.name, payment:content?.value?.fields?.payment, signer:content?.value?.fields?.signer,
+                        operation: content?.value?.fields?.op, amount: content?.value?.fields?.amount, time:content?.value?.fields?.time
+                    } as TreasuryTable_History;
+                } else if (end.includes('::arb::Voted>')) {
+                    return {
+                        object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                        singer:content?.name, vote:content?.value?.fields?.agrees, time: content?.value?.fields?.time,
+                        weight:content?.value?.fields?.weight
+                    } as ArbTable_Vote;
+                } else if (end.includes('::permission::Perm>>')) {
+                    return {
+                        object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                        entity:content?.name, permission:content?.value?.map((v:any) => {
+                            return {id:v?.fields.index, guard:v?.fields.guard}
+                        })
+                    } as PermissionTable_Entity;
+                } else if (end.includes('::repository::DataKey')) {
+                    return {
+                        object:id, type:'ArbTable_Vote', type_raw:type_raw, owner:owner, version:version,
+                        address:content?.name?.fields?.id, key:content?.name?.fields?.key, data:Uint8Array.from(content?.value)
+                    } as RepositoryTable_Data;
+                }
+            }
+        }
+        return {object:id, type:type, type_raw:type_raw, owner:owner, version:version}
+    }
+}

package/src/agent_query/permission.ts

@@ -0,0 +1,60 @@
+/**
+ * Provide a JSON query interface for AI
+ * 
+ */
+
+import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
+import { Protocol, } from '../protocol';
+import { Bcs, IsValidAddress} from '../utils'
+import { Errors, ERROR}  from '../exception'
+import { Permission } from '../permission';
+import { BCS } from '@mysten/bcs';
+import { PermissionAnswerItem, PermissionIndexType, PermissionAnswer } from '../permission';
+
+export interface PermissionQuery {
+    permission_object: string;
+    address: string;
+}
+
+export class PERMISSION_QUERY {
+    /*json: PermissionQuery; return PermissionAnswer */
+    static permission_json = async (json:string) : Promise<string> => {
+        try {
+            const q : PermissionQuery = JSON.parse(json);
+            return JSON.stringify(await PERMISSION_QUERY.permission(q));
+        } catch (e) {
+            return JSON.stringify({error:e});
+        }
+    }
+
+    static permission = async (query:PermissionQuery) : Promise<PermissionAnswer> => {
+        if (!IsValidAddress(query.permission_object)) {
+            ERROR(Errors.IsValidAddress, 'permission.permission_object');
+        }
+        if (!IsValidAddress(query.address)) {
+            ERROR(Errors.IsValidAddress, 'permission.address')
+        }
+        const txb = new TransactionBlock();
+        const object = Permission.From(txb, query.permission_object);
+        object.query_permissions_all(query.address);
+
+
+        const res = await Protocol.Client().devInspectTransactionBlock({sender:query.address, transactionBlock:txb});
+        if (res.results && res.results[0].returnValues && res.results[0].returnValues.length !== 3 )  {
+            ERROR(Errors.Fail, 'permission.retValues')
+        }
+
+        const perm = Bcs.getInstance().de(BCS.U8, Uint8Array.from((res.results as any)[0].returnValues[0][0]));
+        if (perm === Permission.PERMISSION_ADMIN || perm === Permission.PERMISSION_OWNER_AND_ADMIN) {
+            return {who:query.address, admin:true, owner:perm%2===1, items:[], object:query.permission_object}
+        } else {
+            const perms = Bcs.getInstance().de('vector<u64>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
+            const guards = Bcs.getInstance().de_guards(Uint8Array.from((res.results as any)[0].returnValues[2][0]));
+            const items: PermissionAnswerItem[] = [];
+            for(let i = 0; i < perms.length; ++i) {
+                items.push({query:perms[i], permission:true, guard:guards[i] ? ('0x'+guards[i]) : undefined})
+            }
+            return {who:query.address, admin:false, owner:perm%2===1, items:items, object:query.permission_object};  
+        }
+    }
+}

package/src/index.ts

@@ -14,5 +14,9 @@ export * from './resource'
 export * from './treasury'
 export * from './payment'
 export * from './arbitration'
+export * from './agent_query/object'
+export * from './agent_query/permission'
+export * from './agent_query/entity'
+
 // export * from './reward'
 // export * from './vote'

package/src/machine.ts

@@ -487,27 +487,30 @@ export class Machine {
     static rpc_de_nodes(fields: any) : Machine_Node[] {
         const machine_nodes:Machine_Node[] = [];
         fields.forEach((n:any) => {
-            let pairs:Machine_Node_Pair[] = [];
-            n.data.content.fields.value.fields.value.fields.contents.forEach((p:any) => {
-                let forwards:Machine_Forward[] = [];
-                p.fields.value.fields.forwards.fields.contents.forEach((f:any) => {
-                    let forward_name = f.fields.key;
-                    let forward_weight = f.fields.value.fields.weight;
-                    let forward_guard = f.fields.value.fields.guard;
-                    let forward_namedOperator = f.fields.value.fields.namedOperator;
-                    let forward_permission_index = f.fields.value.fields.permission_index;
-                    forwards.push({name:forward_name, namedOperator:forward_namedOperator, permission:forward_permission_index,
-                        weight:forward_weight, guard:forward_guard?forward_guard:'', suppliers:f.fields.value.fields.suppliers.fields.contents.map((v:any) => {
-                            return {object:v.fields.key, bOptional:v.fields.value, pay_token_type:''}
-                        })}); //@ NOTICE...
-                });
-                pairs.push({prior_node:p.fields.key, threshold:p.fields.value.fields.threshold, forwards:forwards});
-            });
-            machine_nodes.push({name:n.data.content.fields.name, pairs:pairs});    
+            machine_nodes.push({name:n.data.content.fields.name, pairs:Machine.rpc_de_pair(n?.data.content.fields.value)});    
         });
         return machine_nodes;
     }
 
+    static rpc_de_pair(data:any) : Machine_Node_Pair[] {
+        let pairs:Machine_Node_Pair[] = [];
+        data.fields.value.fields.contents.forEach((p:any) => {
+            let forwards:Machine_Forward[] = [];
+            p.fields.value.fields.forwards.fields.contents.forEach((f:any) => {
+                let forward_name = f.fields.key;
+                let forward_weight = f.fields.value.fields.weight;
+                let forward_guard = f.fields.value.fields.guard;
+                let forward_namedOperator = f.fields.value.fields.namedOperator;
+                let forward_permission_index = f.fields.value.fields.permission_index;
+                forwards.push({name:forward_name, namedOperator:forward_namedOperator, permission:forward_permission_index,
+                    weight:forward_weight, guard:forward_guard?forward_guard:'', suppliers:f.fields.value.fields.suppliers.fields.contents.map((v:any) => {
+                        return {object:v.fields.key, bOptional:v.fields.value, pay_token_type:''}
+                    })}); //@ NOTICE...
+            });
+            pairs.push({prior_node:p.fields.key, threshold:p.fields.value.fields.threshold, forwards:forwards});
+        });
+        return pairs
+    }
     static namedOperators(nodes:Machine_Node[]) : string[] {
         let ret: string[] = [];
         nodes.forEach((v)=> {

package/src/permission.ts

@@ -487,23 +487,6 @@ export class  Permission {
         });        
     }
 
-    // query some permissions for address
-    query_permissions(address_queried:string, permissions:PermissionIndexType[]) {
-        if (!IsValidAddress(address_queried)) {
-            ERROR(Errors.InvalidParam, 'query_permissions');
-        }
-
-        if (permissions.length === 0 || permissions.length > Permission.MAX_QUERY_COUNT) {
-            ERROR(Errors.InvalidParam, 'permissions count');
-        }
-
-        this.txb.moveCall({
-            target:Protocol.Instance().PermissionFn('query_permissions') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(address_queried), 
-                this.txb.pure.vector('u64', permissions)]
-        })   
-    }
-
     // query all permissions for address
     query_permissions_all(address_queried:string) {
         if (!IsValidAddress(address_queried)) {
@@ -516,13 +499,9 @@ export class  Permission {
         })   
     }
 
-    QueryPermissions(permission:string, address_queried:string, permissions:PermissionIndexType[]|'all', onPermissionAnswer:OnPermissionAnswer, sender?:string) {
+    QueryPermissions(permission:string, address_queried:string, onPermissionAnswer:OnPermissionAnswer, sender?:string) {
         //@ be the same txb
-        if (permissions === 'all') {
-            this.query_permissions_all(address_queried);
-        } else {
-            this.query_permissions(address_queried, permissions);
-        }
+        this.query_permissions_all(address_queried);
 
         Protocol.Client().devInspectTransactionBlock({sender:sender ?? address_queried, transactionBlock:this.txb}).then((res) => {
             if (res.results && res.results[0].returnValues && res.results[0].returnValues.length !== 3 )  {
@@ -533,32 +512,13 @@ export class  Permission {
             if (perm === Permission.PERMISSION_ADMIN || perm === Permission.PERMISSION_OWNER_AND_ADMIN) {
                 onPermissionAnswer({who:address_queried, admin:true, owner:perm%2===1, items:[], object:permission})
             } else {
-                if (permissions === 'all') {
-                    const perms = Bcs.getInstance().de('vector<u64>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
-                    const guards = Bcs.getInstance().de_guards(Uint8Array.from((res.results as any)[0].returnValues[2][0]));
-                    const items: PermissionAnswerItem[] = [];
-                    for(let i = 0; i < perms.length; ++i) {
-                        items.push({query:perms[i], permission:true, guard:guards[i] ? ('0x'+guards[i]) : undefined})
-                    }
-                    onPermissionAnswer({who:address_queried, admin:false, owner:perm%2===1, items:items, object:permission});  
-                } else {
-                    const perms = Bcs.getInstance().de('vector<u8>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
-                    const guards = Bcs.getInstance().de('vector<address>', Uint8Array.from((res.results as any)[0].returnValues[2][0]));
-                    if (perms.length !== permissions.length) {
-                        onPermissionAnswer({who:address_queried, object:permission});
-                        return
-                    }
-
-                    const items: PermissionAnswerItem[] = (permissions as PermissionIndexType[]).map((v, index) => {
-                        const p = perms[index] === Permission.PERMISSION_QUERY_NONE ? false : true;
-                        let g : any = undefined;
-                        if (p && perms[index] < guards.length) {
-                            g = '0x' + guards[perms[index] as number];
-                        }
-                        return {query:v, permission:p, guard:g} 
-                    })
-                    onPermissionAnswer({who:address_queried, admin:false, owner:perm%2===1, items:items, object:permission});                    
+                const perms = Bcs.getInstance().de('vector<u64>', Uint8Array.from((res.results as any)[0].returnValues[1][0]));
+                const guards = Bcs.getInstance().de_guards(Uint8Array.from((res.results as any)[0].returnValues[2][0]));
+                const items: PermissionAnswerItem[] = [];
+                for(let i = 0; i < perms.length; ++i) {
+                    items.push({query:perms[i], permission:true, guard:guards[i] ? ('0x'+guards[i]) : undefined})
                 }
+                onPermissionAnswer({who:address_queried, admin:false, owner:perm%2===1, items:items, object:permission});  
             }
         }).catch((e) => {
             console.log(e);
@@ -586,9 +546,7 @@ export class  Permission {
     static MAX_ENTITY_COUNT = 2000;
     static MAX_PERMISSION_INDEX_COUNT = 200;
     static MAX_PERSONAL_PERMISSION_COUNT = 200; 
-    static MAX_QUERY_COUNT = 250; // 
-    static PERMISSION_QUERY_NONE = 255;
-    static PERMISSION_QUERY_HAS = 254;
+    
     static PERMISSION_NORMAL = 0;
     static PERMISSION_OWNER = 1;
     static PERMISSION_ADMIN = 2;

package/src/progress.ts

@@ -35,9 +35,10 @@ export interface Holder {
     who?:string;
     deliverable: Deliverable;
     accomplished:boolean;
+    time: string;
 }
 export interface Session {
-    id?:number; // for parent progress's history
+    id?: number; // sid
     next_node: string;
     holders: Holder[];
     weights: number;
@@ -46,6 +47,13 @@ export interface Session {
     bComplete?: boolean;
 }
 
+export interface History {
+    id: number;  // sid
+    node: string;
+    next_node: string;
+    time: string;
+    sessions: Session[];
+}
 export class Progress {
     protected permission ;
     protected machine;
@@ -327,9 +335,8 @@ export class Progress {
         session?.fields?.contents?.forEach((v:any) => {
             var s:Session = {next_node: v.fields.key, holders:[], weights:v.fields.value.fields.weights, threshold:v.fields.value.fields.threshold};
             v.fields.value.fields.forwards.fields.contents.forEach((i:any) => {
-              s.holders.push({forward:i.fields.key, accomplished:i.fields.value.fields.accomplished, 
-                who:i.fields.value.fields.who, deliverable:{msg:i.fields.value.fields.msg, 
-                    orders:i.fields.value.fields.orders ?? []},
+              s.holders.push({forward:i.fields.key, accomplished:i.fields.value.fields.accomplished, time:i.fields.value.fields.time,
+                who:i.fields.value.fields.who, deliverable:{msg:i.fields.value.fields.msg, orders:i.fields.value.fields.orders ?? []},
               })
             })
             sessions.push(s);
@@ -337,23 +344,16 @@ export class Progress {
         return sessions;
     }
 
-    static rpc_de_history = (fields: any) : Session[] => {
-        let sessions : Session[] = [];
-        fields?.forEach((v:any) => {
-          const next_node = v.data.content.fields.value.fields.next_node;
-          v.data.content.fields.value.fields.session.fields.contents.forEach((i:any) => {
-            var s:Session = {id:v.data.content.fields.name,
-                node:v.data.content.fields.value.fields.node, next_node: i.fields.key, holders:[], 
-              weights:i.fields.value.fields.weights, threshold:i.fields.value.fields.threshold, bComplete:i.fields.key === next_node};
-              i.fields.value.fields.forwards.fields.contents.forEach((k:any) => {
-              s.holders.push({forward:k.fields.key, who:k.fields.value.fields.who, accomplished:k.fields.value.fields.accomplished,
-                deliverable:{msg:k.fields.value.fields.msg, 
-                    orders:k.fields.value.fields.orders ?? []}});
-            })
-            sessions.push(s);
-          })
+    static rpc_de_histories = (fields: any) : History[] => {
+        return fields?.map((v:any) => {
+          return Progress.rpc_de_history(v?.data?.content?.fields)
         })
-        return sessions;
+    }
+
+    static rpc_de_history = (data: any) : History => {
+        return {id:parseInt(data?.name), node:data?.value?.fields?.node, next_node:data?.value?.fields?.next_node, 
+            sessions:Progress.rpc_de_sessions(data?.value.fields?.session), time: data?.value?.fields?.time
+          }
     }
 
     static MAX_NAMED_OPERATOR_COUNT = 20;

package/src/protocol.ts

@@ -14,10 +14,8 @@ export enum MODULES {
     permission = 'permission',
     passport = 'passport',
     guard = 'guard',
-    vote = 'vote',
     demand = 'demand',
     order = 'order',
-    reward = 'reward',
     service = 'service',
     resource = 'resource',
     entity = 'entity',
@@ -221,15 +219,15 @@ const TESTNET = {
 }
 */
 const TESTNET = {
-    wowok: "0x66f08884668a7b18b34ce0ae91cfb7bdab284d4dbbc28ad3fb009df50f88e11e",
-    wowok_origin:'0x66f08884668a7b18b34ce0ae91cfb7bdab284d4dbbc28ad3fb009df50f88e11e' ,
-    base: '0x3960658ad695c829bd62a083a8a92f94f04404ae3ea6b13bbc72e5780cfeec4c',
-    base_origin: '0x3960658ad695c829bd62a083a8a92f94f04404ae3ea6b13bbc72e5780cfeec4c',
-
-    wowok_object: '0xa51c94e11a4693e63b77cc6577a2deb0e4eed1cc6a1fbc3971b35edafc72eaed',
-    entity_object: '0x5f45ec58ed208c7b1b5d427fa77bbc64ad2256203aa6f11961b9417a7eeca053',
-    treasury_cap:'0xc1f614972987e8839584710c0a8b9f284745e667f2e19594c0ffa09ca5e59721',
-    oracle_object:'0x57c89a7ba9f2aaf784a5325da111989f157939a14df15bb9698de0a46285d746',
+    wowok: "0x7bb3672fb818b362703a2f2e0804c4cea6b5a23dc79920217088374450300f45",
+    wowok_origin:'0x7bb3672fb818b362703a2f2e0804c4cea6b5a23dc79920217088374450300f45' ,
+    base: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
+    base_origin: '0x75eae2a5c8e9bcee76ff8f684bcc38e49a26530526ef8c32703dc0b4a4281f93',
+
+    wowok_object: '0x6f0b0c6d1d6b02e8589064c0c40d6aed105c5cc5ffece509111a8d308e3eb188',
+    entity_object: '0x42a28bf08b8373cc460b001eab9d9cd91c4285855bea0dc40116237de79870b8',
+    treasury_cap:'0x9f415c863f0c26103e70fc4a739fea479ff20544057a3c5665db16c0b8650f7c',
+    oracle_object:'0x6c7d9b8ab0e9d21291e0128ca3e0d550b30f375f1e008381f2fbeef6753e6dcf',
 }
 const MAINNET = {
     wowok: "",
@@ -334,10 +332,8 @@ export class Protocol {
     RepositoryFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.repository}::${fn}`};
     PermissionFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.permission}::${fn}`};
     PassportFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.passport}::${fn}`};
-    VoteFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.vote}::${fn}`};
     DemandFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.demand}::${fn}`};
     OrderFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.order}::${fn}`};
-    RewardFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.reward}::${fn}`};
     ServiceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.service}::${fn}`};
     ResourceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.resource}::${fn}`};
     EntityFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.entity}::${fn}`};
@@ -476,9 +472,9 @@ export class Protocol {
         { let i = (key === MODULES.guard ? this.package.get('base') : this.package.get('wowok')) + '::' + key + '::';  return i + capitalize(key); })
     WOWOK_OBJECTS_PREFIX_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
         { return (key === MODULES.guard ? this.package.get('base') : this.package.get('wowok'))  + '::' + key + '::'; })
-    private hasPackage(pack:string) : boolean {
+    hasPackage(pack:string) : boolean {
         for (let value of this.package.values()) {
-            if (value === pack) {
+            if (pack.includes(value)) {
                 return true;
             }
         } return false;

package/src/repository.ts

@@ -10,6 +10,11 @@ export enum Repository_Policy_Mode {
     POLICY_MODE_STRICT = 1,
 }
 
+export enum Repository_Type {
+    NORMAL = 0,
+    WOWOK_GRANTEE = 1,
+    WOWOK_ORACLE = 2
+}
 export interface RepData {
     id: string;
     name: string;
@@ -21,8 +26,8 @@ export interface RepData {
 export type Repository_Policy = {
     key:string;
     description: string;
-    data_type: RepositoryValueType;
-    permission?: PermissionIndexType; // PermissionIndex like, must be geater than 1000
+    dataType: RepositoryValueType;
+    permissionIndex?: PermissionIndexType | null; // PermissionIndex like, must be geater than 1000
 }
 export type Repository_Policy_Data = {
     key: string;
@@ -51,7 +56,7 @@ export class Repository {
         return r
     }
     static New(txb:TransactionBlock, permission:PermissionObject, description:string, 
-        policy_mode: Repository_Policy_Mode, passport?:PassportObject) : Repository {
+        policy_mode: Repository_Policy_Mode=Repository_Policy_Mode.POLICY_MODE_FREE, passport?:PassportObject) : Repository {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects, 'permission')
         }
@@ -213,14 +218,14 @@ export class Repository {
         }
 
         policies.forEach((policy) => {
-            let permission_index = this.txb.pure.option('u64', policy?.permission ? policy?.permission : undefined);
+            let permission_index = this.txb.pure.option('u64', policy?.permissionIndex ? policy?.permissionIndex : undefined);
             if (passport) {
                 this.txb.moveCall({
                     target:Protocol.Instance().RepositoryFn('policy_add_with_passport') as FnCallType,
                     arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
                         this.txb.pure.string(policy.key), 
                         this.txb.pure.string(policy.description),
-                        permission_index, this.txb.pure.u8(policy.data_type),
+                        permission_index, this.txb.pure.u8(policy.dataType),
                         Protocol.TXB_OBJECT(this.txb, this.permission)]
                 })              
             } else {
@@ -229,7 +234,7 @@ export class Repository {
                     arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
                         this.txb.pure.string(policy.key), 
                         this.txb.pure.string(policy.description),
-                        permission_index, this.txb.pure.u8(policy.data_type),
+                        permission_index, this.txb.pure.u8(policy.dataType),
                         Protocol.TXB_OBJECT(this.txb, this.permission)]
                 })  
             }
@@ -376,15 +381,11 @@ export class Repository {
         this.permission = new_permission  
     }
 
-    static MAX_POLICY_COUNT = 200;
+    static MAX_POLICY_COUNT = 120;
     static MAX_KEY_LENGTH = 128;
     static MAX_VALUE_LENGTH = 204800;
     static MAX_REFERENCE_COUNT = 100;
 
-    static TYPE_NORMAL = 0;
-    static TYPE_WOWOK_GRANTEE = 1;
-    static TYPE_WOWOK_ORACLE = 2;
-
     static IsValidName = (key:string)  => {
         return key.length <= Repository.MAX_KEY_LENGTH && key.length != 0;
     }

package/src/service.ts

@@ -18,10 +18,10 @@ export type Service_Guard_Percent = {
     percent: number;
 }
 export type Service_Sale = {
-    item:string;
-    price:bigint;
-    stock:bigint;
-    endpoint?:string;
+    item: string;
+    price: string;
+    stock: string;
+    endpoint?:string | null;
 }
 export enum Service_Discount_Type {
     ratio = 0, // -off%
@@ -581,7 +581,7 @@ export class Service {
             ERROR(Errors.InvalidParam, 'add_sales')
         }
         
-        let names: string[]  = []; let price: bigint[] = []; let stock: bigint[] = []; let endpoint: string[] = [];
+        let names: string[]  = []; let price: string[] = []; let stock: string[] = []; let endpoint: string[] = [];
         sales.forEach((s) => {
             if (s.endpoint && !IsValidEndpoint(s.endpoint)) {
                 ERROR(Errors.IsValidEndpoint, 'add_sales')

package/src/treasury.ts

@@ -4,13 +4,17 @@ import { FnCallType, Protocol, PassportObject, PermissionObject, TreasuryAddress
 import { IsValidDesription, IsValidU64, IsValidAddress, IsValidArgType, IsValidArray, parseObjectType} from './utils'
 import { Errors, ERROR}  from './exception'
 
-export enum WithdrawMode {
+export enum Treasury_WithdrawMode {
     PERMISSION = 0,
     GUARD_ONLY_AND_IMMUTABLE = 1,
     BOTH_PERMISSION_AND_GUARD = 2,
 }
 
-
+export enum Treasury_Operation {
+    WITHDRAW = 1,
+    DEPOSIT = 2,
+    RECEIVE = 4,
+}
 export interface DepositParam {
     coin: CoinObject,
     index: bigint,
@@ -315,7 +319,7 @@ export class Treasury {
         }
     }
     
-    set_withdraw_mode(mode: WithdrawMode, passport?: PassportObject)  {
+    set_withdraw_mode(mode: Treasury_WithdrawMode, passport?: PassportObject)  {
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().TreasuryFn('withdraw_mode_set_with_passport') as FnCallType,
@@ -414,10 +418,6 @@ export class Treasury {
     static parseObjectType = (chain_type:string) : string =>  {
         return parseObjectType(chain_type, 'treasury::Treasury<')
     }
-
-    static OP_WITHDRAW = 1;
-    static OP_DEPOSIT = 2;
-    static OP_RECEIVE = 4;
     
     static MAX_WITHDRAW_GUARD_COUNT = 16;
 }