wowok 1.7.10 → 1.7.13

package/src/passport.ts

@@ -2,9 +2,9 @@ import { type TransactionObjectInput, Inputs, Transaction as TransactionBlock, T
 import { SuiObjectResponse } from '@mysten/sui/client';
 import { FnCallType, GuardObject, Protocol, ContextType, OperatorType, Data_Type,
     ValueType, SER_VALUE, IsValidOperatorType } from './protocol.js';
-import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray, insertAtHead, readOption, readOptionString } from './utils.js';
+import { parse_object_type, array_unique, Bcs, ulebDecode, IsValidAddress, IsValidArray, insertAtHead, readOption, readOptionString, deepCopy } from './utils.js';
 import { ERROR, Errors } from './exception.js';
-import { Guard, GuardMaker } from './guard.js';
+import { CMD_CHECK_GUARD, Guard, GuardMaker } from './guard.js';
 import { bcs } from '@mysten/sui/bcs';
 
 export type Guard_Query_Object = {
@@ -102,7 +102,7 @@ export class GuardParser {
         switch (current.type) {
             case OperatorType.TYPE_LOGIC_NOT:
                 current.ret_type = ValueType.TYPE_BOOL;
-                if (stack.length < 1) ERROR(Errors.Fail, 'ResolveData: TYPE_LOGIC_NOT');
+                if (stack.length < 1) ERROR(Errors.Fail, `ResolveData: TYPE_LOGIC_NOT`);
 
                 var param = stack.pop() as DeGuardData;
                 if (!param.ret_type || param.ret_type !=  ValueType.TYPE_BOOL) {
@@ -121,6 +121,18 @@ export class GuardParser {
                     ERROR(Errors.Fail, 'ResolveData: TYPE_NUMBER_ADDRESS type invalid');
                 }
 
+                current.child.push(param);
+                stack.push(current);
+                return;
+            case OperatorType.TYPE_STRING_LOWERCASE:
+                current.ret_type = ValueType.TYPE_STRING;
+                if (stack.length < 1) ERROR(Errors.Fail, 'ResolveData: TYPE_STRING_LOWERCASE');
+
+                var param = stack.pop() as DeGuardData;
+                if (!param.ret_type || param.ret_type !== ValueType.TYPE_STRING) {
+                    ERROR(Errors.Fail, 'ResolveData: TYPE_STRING_LOWERCASE type invalid');
+                }
+
                 current.child.push(param);
                 stack.push(current);
                 return;
@@ -244,12 +256,13 @@ export class GuardParser {
                 return;
                 
         }   
-        ERROR(Errors.Fail, 'OperateParamCount: type  invalid ' + current.type);
+        ERROR(Errors.Fail, 'OperateParamCount: type invalid ' + current.type);
     }
 
-    private static  Parse_Guard_Helper(guards: string[], res:SuiObjectResponse[]) {
+    private static  Parse_Guard_Helper(guards: string[], res:SuiObjectResponse[]) : GuardParser{
         const protocol = Protocol.Instance();
         const me = new GuardParser(guards);
+        
         res.forEach((r) => {
             const c = r.data?.content as any;
             if (!c) ERROR(Errors.Fail, 'Parse_Guard_Helper invalid content');
@@ -267,25 +280,70 @@ export class GuardParser {
         return me
     }
 
-    static Create = async (guards: string[], onGuardInfo?:(parser:GuardParser|undefined)=>void) => {
+    static Create = async (guards: string[]) : Promise<GuardParser | undefined> => {
         if (!IsValidArray(guards, IsValidAddress)) {
-            if (onGuardInfo) onGuardInfo(undefined);
-            return undefined;
+            ERROR(Errors.InvalidParam, 'GuardParser.Create: guards invalid');
         }
 
         let guard_list = array_unique(guards);
-        if (onGuardInfo) {
-            Protocol.Instance().query_raw(guard_list)
-                .then((res) => { 
-                    onGuardInfo(GuardParser.Parse_Guard_Helper(guards, res)); 
-                }).catch((e) => { 
-                    console.log(e);
-                    onGuardInfo(undefined); 
-                })            
-        } else {
-            const res = await Protocol.Instance().query_raw(guard_list);
-            return GuardParser.Parse_Guard_Helper(guards, res);
+        let check_guards = [...guard_list]; 
+        let i = 0; const parsers : GuardParser[] = [];
+
+        for (;i < GuardParser.MAX_REPOSITORY_DEPTH; ++i) {  
+            const res = await Protocol.Instance().query_raw(check_guards);
+            const p = GuardParser.Parse_Guard_Helper(guards, res);
+
+            const repositories: string[] = [];
+            p.guardlist().forEach((g) => {
+                g.input.forEach((i) => {
+                    if (i.cmd !== undefined && CMD_CHECK_GUARD.includes(i.cmd)) {
+                        if (i.identifier !== undefined) {
+                            const id = g.constant.find((c) => c.identifier === i.identifier);
+                            if (id && id.value) {
+                                repositories.push(id.value);
+                            } 
+                        } else if (i.value) {
+                            repositories.push(i.value as string);
+                        }
+                    }
+                });  
+            });
+
+            parsers.push(p);
+            if (repositories.length === 0) {
+                break;
+            }
+
+            check_guards = await GuardParser.RepositoryGuards(repositories);
+            if (check_guards.length === 0) {
+                break;
+            }
+        }
+
+        if (i >= GuardParser.MAX_REPOSITORY_DEPTH) {
+            ERROR(Errors.Fail, `GuardParser.Create: Retrieve guards from the Repository with a maximum depth of more than ${GuardParser.MAX_REPOSITORY_DEPTH} levels.`);
+        }
+
+        // concatenate all parsers
+        for (let i = 1; i < parsers.length; ++i) {
+            parsers[0].guard_list = parsers[0].guard_list.concat(deepCopy(parsers[i].guard_list));
+            parsers[0].guards = parsers[0].guards.concat(parsers[i].guards);
+        }
+        if (parsers.length > 0) {
+            return parsers[0];
+        }
+    }
+
+    // fetch repository guards
+    static RepositoryGuards = async (repositories: string[]) : Promise<string[]> => {
+        const res = await Protocol.Instance().query_raw(repositories);
+        const guards : string[] = [];
+        for (let i=0; i < res.length; ++i) {
+            if ((res[i].data?.content as any)?.fields?.guard) {
+                guards.push((res[i].data?.content as any).fields.guard);
+            }
         }
+        return guards;
     }
 
     future_fills = () : WitnessFill[] => {
@@ -369,6 +427,7 @@ export class GuardParser {
                 case ContextType.TYPE_GUARD:
                 case OperatorType.TYPE_LOGIC_NOT:
                 case OperatorType.TYPE_NUMBER_ADDRESS:
+                case OperatorType.TYPE_STRING_LOWERCASE:
                     break;
                 case OperatorType.TYPE_LOGIC_AS_U256_GREATER:
                 case OperatorType.TYPE_LOGIC_AS_U256_GREATER_EQUAL:
@@ -593,6 +652,7 @@ export class GuardParser {
             }
         }
     }
+    static MAX_REPOSITORY_DEPTH = 3;
 }
 
 export class Passport {

package/src/permission.ts

@@ -10,6 +10,7 @@ export enum PermissionIndex {
     repository_mode = 102,
     repository_policies = 103,
     repository_reference = 104,
+    repository_guard = 105,
 
     service = 200,
     service_description = 201,
@@ -30,6 +31,7 @@ export enum PermissionIndex {
     service_treasury = 216,
     service_arbitration = 217,
     service_location = 218,
+    service_refund = 219,
 
     demand = 260,
     demand_refund = 261,
@@ -93,6 +95,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     {index:PermissionIndex.repository_mode, name:'Policy mode', description:'Set Repository mode', module: MODULES.repository},
     {index:PermissionIndex.repository_policies, name:'Policy', description:'Set Repository policies', module: MODULES.repository},
     {index:PermissionIndex.repository_reference, name:'Reference', description:'Set Repository reference', module: MODULES.repository},
+    {index:PermissionIndex.repository_guard, name:'Guard', description:'Set Guard for data query', module: MODULES.repository},
 
     {index:PermissionIndex.service, name:'Service', description:'Launch new Service', module: MODULES.service},
     {index:PermissionIndex.service_description, name:'Description', description:'Set Service description', module: MODULES.service},
@@ -112,6 +115,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     {index:PermissionIndex.service_treasury, name:'Treasury', description:'Externally withdrawable treasury for compensation or rewards', module: MODULES.service},
     {index:PermissionIndex.service_arbitration, name:'Arbitration', description:'Add/Remove arbitration that allows refunds from orders at any time based on arbitration results', module: MODULES.service},
     {index:PermissionIndex.service_location, name:'Location', description:'Set Service location', module: MODULES.service},
+    {index:PermissionIndex.service_refund, name:'Refund', description:'Initiate order refund', module: MODULES.service},
 
     {index:PermissionIndex.demand, name:'Demand', description:'Launch new Demand', module: MODULES.demand},
     {index:PermissionIndex.demand_refund, name:'Refund', description:'Refund from Demand', module: MODULES.demand},

package/src/protocol.ts

@@ -78,6 +78,7 @@ export enum OperatorType {
     TYPE_NUMBER_DEVIDE = 5, 
     TYPE_NUMBER_MOD = 6,
     TYPE_NUMBER_ADDRESS = 7,
+    TYPE_STRING_LOWERCASE = 8, // string to lowercase
 
     TYPE_LOGIC_AS_U256_GREATER = 11,
     TYPE_LOGIC_AS_U256_GREATER_EQUAL = 12,
@@ -210,15 +211,15 @@ export enum ENTRYPOINT {
 }
 
 const TESTNET = {
-    wowok: "0x661357b99ce7ece747c9ef365a5bf555f5ebeac8effed12d0f5920816e618de4",
-    wowok_origin:'0x661357b99ce7ece747c9ef365a5bf555f5ebeac8effed12d0f5920816e618de4' ,
-    base: '0xae90f6a083954653560771bc1cff940bcd532c1f348a69ff03770335c6c52173',
-    base_origin: '0xae90f6a083954653560771bc1cff940bcd532c1f348a69ff03770335c6c52173',
-
-    wowok_object: '0xb36e50e9a9dab110b385304f82c440ff04a5cd6a84b4c12d9131811b262c7373',
-    entity_object: '0x6a9c149565dd2bf0c9e04fd59965403c741180db7960c100606b8ae19b84ef73',
-    treasury_cap:'0xecc1a7c48f15f0b85d515a1bd3c9cd53c2e1fe50944db29e85b9355cc7827829',
-    oracle_object:'0x0a7fedc81b6d33e9791d78df8bfb2c7c60e3681462dba82926d8e1f961690f59',
+    wowok: "0x245f15f58b5e5bd790e7dcdb5bd66d647b4fc60c6265c6a91f20e33cbef54202",
+    wowok_origin:'0x245f15f58b5e5bd790e7dcdb5bd66d647b4fc60c6265c6a91f20e33cbef54202' ,
+    base: '0x5322c1df09a3d0fd4cb5cd933dc39ee11872a10b21c5aef794702661070ab182',
+    base_origin: '0x5322c1df09a3d0fd4cb5cd933dc39ee11872a10b21c5aef794702661070ab182',
+
+    wowok_object: '0x88db80974d677ab6c8a783f5c89e41ae9ecbb76962684788523f5df4acde40a4',
+    entity_object: '0x160816194a1b50534d96c73064ac69af76e1e72262adf7b17d8552a1b833a263',
+    treasury_cap:'0xc1a799cf0b3e6854359e4cd1724b20b25d612a0d951bacb7c7d208f6d26534a7',
+    oracle_object:'0xec39bc61ff38d3ed54b2a5afedc21158ff93686064f353ae169f97907b493fde',
 }
 const MAINNET = {
     wowok: "",

package/src/repository.ts

@@ -1,4 +1,4 @@
-import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject, } from './protocol.js';
+import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject, GuardObject, } from './protocol.js';
 import { PermissionIndexType, Permission } from './permission.js'
 import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, IsValidName,  ValueTypeConvert, IsValidStringLength, uint2address} from './utils.js';
 import { ERROR, Errors } from './exception.js';
@@ -446,6 +446,38 @@ export class Repository {
         }  
     }
 
+    set_guard(guard?:GuardObject | null, passport?:PassportObject)  {
+        if (guard && !Protocol.IsValidObjects([guard])) {
+            ERROR(Errors.IsValidObjects, `set_guard.guard ${guard}`);
+        }
+
+        if (passport) {
+            if (guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().repositoryFn('guard_set_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, guard), Protocol.TXB_OBJECT(this.txb, this.permission)]
+                })  
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().repositoryFn('guard_none_with_passport') as FnCallType,
+                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)]
+                })
+            }
+        } else {
+            if (guard) {
+                this.txb.moveCall({
+                    target:Protocol.Instance().repositoryFn('guard_set') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, guard), Protocol.TXB_OBJECT(this.txb, this.permission)]
+                })  
+            } else {
+                this.txb.moveCall({
+                    target:Protocol.Instance().repositoryFn('guard_none') as FnCallType,
+                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)]
+                })
+            }
+        }  
+    }
+
     set_policy_description(policy:string, description:string, passport?:PassportObject)  {
         if (!Repository.IsValidName(policy)) {
             ERROR(Errors.IsValidName, 'policy')

package/src/service.ts

@@ -965,6 +965,24 @@ export class Service {
             })   
         }    
     } */
+    refund_by_service(order:OrderObject, passport?:PassportObject) {
+        if (!Protocol.IsValidObjects([order])) {
+            ERROR(Errors.IsValidObjects, `refund_by_service.order ${order}`)
+        }
+        if (passport) {
+            this.txb.moveCall({
+                target:Protocol.Instance().serviceFn('refund_by_service_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })     
+        } else {
+            this.txb.moveCall({
+                target:Protocol.Instance().serviceFn('refund_by_service') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), Protocol.TXB_OBJECT(this.txb, this.permission)],
+                typeArguments:[this.pay_token_type]
+            })     
+        }    
+    }
 
     pause(pause:boolean, passport?:PassportObject) {
         if (passport) {
@@ -996,7 +1014,7 @@ export class Service {
             typeArguments:[this.pay_token_type, arb_type]
             })     
     }
-
+    
     refund(order:OrderObject, refund_guard?:GuardObject, passport?:PassportObject) {
         if (!Protocol.IsValidObjects([order])) {
             ERROR(Errors.IsValidObjects, 'refund.order')

package/src/utils.ts

@@ -120,6 +120,20 @@ export const concatenate = (resultConstructor:any, ...arrays:any[]) => {
     return result;
 }
 
+export function deepCopy<T>(obj: T): T {
+  if (obj === null || typeof obj !== 'object') {
+    return obj;
+  }
+ 
+  const copy: any = Array.isArray(obj) ? [] : {};
+  for (const key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      copy[key] = deepCopy(obj[key]);
+    }
+  }
+  return copy;
+}
+
 export const parseObjectType = (chain_type:string | null | undefined, header:string='payment::Payment<') : string =>  {
     if (chain_type) {
         const i = chain_type.indexOf(header);
@@ -163,22 +177,17 @@ export function parse_object_type(object_data:string) : string[] {
     return object_type;
 }
 
-export interface Entity_Info {
-    name: string;
-    description?: string;
-    avatar?: string;
-    twitter?: string;
-    discord?: string;
-    homepage?: string;
-}
-
 export class Bcs {
     private static _instance : any;
+
+    private VecMapStruct = bcs.struct('VecMap', {
+        contents: bcs.vector(bcs.tuple([bcs.string(), bcs.string()])),
+    });
+
     private EntStruct = bcs.struct('EntStruct', {
-        avatar: bcs.vector(bcs.u8()),
+        description: bcs.string(),
+        info: this.VecMapStruct,
         resource: bcs.option(bcs.Address),
-        safer_name: bcs.vector(bcs.string()),
-        safer_value: bcs.vector(bcs.string()),
         like: bcs.u32(),
         dislike: bcs.u32(),
     });
@@ -186,14 +195,6 @@ export class Bcs {
         nick: bcs.string(),
         tags: bcs.vector(bcs.string()),
     })
-    private PersonalInfo = bcs.struct('PersonalInfo', {
-        name: bcs.string(),
-        description: bcs.string(),
-        avatar: bcs.string(),
-        twitter: bcs.string(),
-        discord: bcs.string(),
-        homepage: bcs.string(),
-    })
     private Guards = bcs.struct('Guards', {
         address: bcs.option(bcs.Address),
     })
@@ -325,20 +326,7 @@ export class Bcs {
         const struct_vec = bcs.vector(bcs.u8()).parse(data);
         return this.EntStruct.parse(Uint8Array.from(struct_vec))
     }  
-    se_entInfo(info: Entity_Info) {
-        return this.PersonalInfo.serialize({
-            name: info.name ?? '',
-            description: info.description ?? '',
-            avatar: info.avatar ?? '',
-            twitter: info.twitter ?? '',
-            discord: info.discord ?? '',
-            homepage: info.homepage ?? '',
-        }).toBytes();
-    }
-    de_entInfo(data:Uint8Array | undefined) : any | undefined {
-        if (!data || data.length === 0) return undefined
-        return this.PersonalInfo.parse(data);
-    }    
+
     de_tags(data:Uint8Array | undefined) : any | undefined {
         if (!data || data.length === 0) return undefined;
         const struct_vec = bcs.vector(bcs.u8()).parse(data);