wowok 1.3.3 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.3.3",
+  "version": "1.3.6",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/demand.ts

@@ -24,7 +24,7 @@ export class Demand {
         this.txb = txb;
         this.object = '';
     }
-    static New(txb:TransactionBlock, bounty_type:string, permission:PermissionObject, description:string, 
+    static New(txb:TransactionBlock, bounty_type:string, ms_expand:boolean, time:number, permission:PermissionObject, description:string, 
         bounty:TransactionResult | string, passport?:PassportObject) : Demand {
         if (!Protocol.IsValidObjects([permission, bounty])) {
             ERROR(Errors.IsValidObjects, 'permission, bounty');
@@ -35,18 +35,24 @@ export class Demand {
         if (!IsValidArgType(bounty_type)) {
             ERROR(Errors.IsValidArgType, bounty_type);
         }
-
+        if (!IsValidUintLarge(time)) {
+            ERROR(Errors.IsValidUint, 'time')
+        }
+        
         let  d = new Demand(txb, bounty_type, permission);
+        const clock = txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
             d.object = txb.moveCall({
                 target:Protocol.Instance().DemandFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure.string(description), txb.object(bounty), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[passport, txb.pure.string(description), txb.object(bounty), txb.pure.bool(ms_expand), txb.pure.u64(time), 
+                    txb.object(clock), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[bounty_type],
             })        
         } else {
             d.object = txb.moveCall({
                 target:Protocol.Instance().DemandFn('new') as FnCallType,
-                arguments:[txb.pure.string(description), txb.object(bounty), Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure.string(description), txb.object(bounty), txb.pure.bool(ms_expand), txb.pure.u64(time), 
+                    txb.object(clock), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[bounty_type],
             })        
         }

package/src/exception.ts

@@ -9,6 +9,7 @@ export enum Errors {
     IsValidTokenType = 'invalid token type',
     IsValidUint = 'invalid uint',
     IsValidInt = 'invalid int', 
+    IsValidU64 = 'invalid u64',
     IsValidPercent = 'invalid percent',
     IsValidArray = 'invalid array',
     IsValidObjects = 'invalid objects',

package/src/machine.ts

@@ -223,13 +223,13 @@ export class Machine {
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().MachineFn('node_remove_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), 
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure.vector('string', nodes_name), 
                     this.txb.pure.bool(bTransferMyself), Protocol.TXB_OBJECT(this.txb, this.permission)],
             });  
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().MachineFn('node_remove') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), 
+                arguments:[Protocol.TXB_OBJECT(this.txb,  this.object), this.txb.pure.vector('string', nodes_name), 
                     this.txb.pure.bool(bTransferMyself), Protocol.TXB_OBJECT(this.txb, this.permission)],
             });
         } 

package/src/passport.ts

@@ -478,11 +478,15 @@ export class GuardParser {
 
         let guard_list = array_unique(guards);
         const protocol = Protocol.Instance();
-        
+
         if (onGuardInfo) {
             protocol.Query_Raw(guard_list)
-                .then((res) => { onGuardInfo(GuardParser.Parse_Guard_Helper(guards, res)); })
-                .catch((e) => { onGuardInfo(undefined); })            
+                .then((res) => { 
+                    onGuardInfo(GuardParser.Parse_Guard_Helper(guards, res)); 
+                }).catch((e) => { 
+                    console.log(e);
+                    onGuardInfo(undefined); 
+                })            
         } else {
             const res = await protocol.Query_Raw(guard_list);
             return GuardParser.Parse_Guard_Helper(guards, res);
@@ -638,7 +642,6 @@ export class GuardParser {
                 objects.push(this.get_object(g.id, q, fill));
             })
         })
-
         if (onPassportQueryReady) {
             Protocol.Instance().Query_Raw(array_unique(objects), {showType:true}).then((res) => {
                 onPassportQueryReady(this.done_helper(res));

package/src/permission.ts

@@ -38,7 +38,7 @@ export enum PermissionIndex {
     service_remove_sales = 213,
     service_discount_transfer = 214,
     service_withdraw = 216,
-    service_buy_guard = 217,
+    service_buyer_guard = 217,
     service_machine = 218,
     service_endpoint = 219,
     service_publish = 220,
@@ -135,7 +135,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     {index:PermissionIndex.service_remove_sales, name:'Remove sales', description:'Remove sale items for Service', module: 'service'},
     {index:PermissionIndex.service_discount_transfer, name:'Discount', description:'Launch discounts for Service', module: 'service'},
     {index:PermissionIndex.service_withdraw, name:'Withdraw', description:'Widthraw from Service orders', module: 'service'},
-    {index:PermissionIndex.service_buy_guard, name:'Buyer Guard', description:'Set Guard of buying for Service', module: 'service'},
+    {index:PermissionIndex.service_buyer_guard, name:'Buyer Guard', description:'Set Guard of buying for Service', module: 'service'},
     {index:PermissionIndex.service_machine, name:'Machine', description:'Set Machine for Service', module: 'service'},
     {index:PermissionIndex.service_endpoint, name:'Endpoint', description:'Set Service endpoint', module: 'service'},
     {index:PermissionIndex.service_publish, name:'Publish', description:'Publish Service', module: 'service'},
@@ -375,7 +375,7 @@ export class  Permission {
         this.txb.moveCall({
             target:Protocol.Instance().PermissionFn('remove_index') as FnCallType,
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(entity_address), 
-                this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, array_unique(index)))]
+                this.txb.pure.vector('u64', array_unique(index))]
         })            
     }
     remove_entity(entity_address:string[])  {
@@ -444,6 +444,8 @@ export class  Permission {
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(new_owner)]
         });        
     }
+
+    // query some permissions for address
     query_permissions(address_queried:string, permissions:PermissionIndexType[]) {
         if (!IsValidAddress(address_queried)) {
             ERROR(Errors.InvalidParam, 'query_permissions');
@@ -460,46 +462,72 @@ export class  Permission {
         })   
     }
 
-    QueryPermissions(permission:string, address_queried:string, permissions:PermissionIndexType[], onPermissionAnswer:OnPermissionAnswer, sender?:string) {
+    // query all permissions for address
+    query_permissions_all(address_queried:string) {
+        if (!IsValidAddress(address_queried)) {
+            ERROR(Errors.InvalidParam, 'query_permissions');
+        }
+
+        this.txb.moveCall({
+            target:Protocol.Instance().PermissionFn('query_permissions_all') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(address_queried)]
+        })   
+    }
+
+    QueryPermissions(permission:string, address_queried:string, permissions:PermissionIndexType[]|'all', onPermissionAnswer:OnPermissionAnswer, sender?:string) {
         //@ be the same txb
-        this.query_permissions(address_queried, permissions);
+        if (permissions === 'all') {
+            this.query_permissions_all(address_queried);
+        } else {
+            this.query_permissions(address_queried, permissions);
+        }
+
         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 )  {
                 onPermissionAnswer({who:address_queried, object:permission});
                 return 
             }
-
             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) {
                 onPermissionAnswer({who:address_queried, admin:true, owner:perm%2===1, 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.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];
+                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
                     }
-                    return {query:v, permission:p, guard:g} 
-                })
-                onPermissionAnswer({who:address_queried, admin:false, owner:perm%2===1, items:items, object:permission});
+
+                    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});                    
+                }
             }
         }).catch((e) => {
             console.log(e);
             onPermissionAnswer({who:address_queried, object:permission});
         })
     }
+    
     static HasPermission(answer:PermissionAnswer|undefined, index:PermissionIndexType, bStrict:boolean=false) : {has:boolean, guard?:string, owner?:boolean} | undefined {
         if (answer) {
             if (answer.admin) return {has:true, owner:answer.owner}; // admin
-            let i = answer.items?.find((v)=>v.query === index);
+            let i = answer.items?.find((v)=>v.query == index); // index maybe string, so ==
             if (i) {
                 return {has:i.permission, guard:i.guard, owner:answer.owner};
             }    

package/src/progress.ts

@@ -272,7 +272,6 @@ export class Progress {
         let sub = this.txb.pure.option('address', sub_id ? sub_id : undefined);
         
         if (passport) {
-            console.log(11111)
             this.txb.moveCall({
                 target:Protocol.Instance().ProgressFn('next_with_passport') as FnCallType,
                 arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.machine), 

package/src/protocol.ts

@@ -191,9 +191,9 @@ export enum ENTRYPOINT {
 }
 
 const TESTNET = {
-    package: "0x8f547c4bd00eedc72307d67c8c1c7b22da88c29ac530cce57bbfe7b6add45a91",
-    wowok_object: '0x1ccee2dbac69f76db35d92869cc4840fb537020a927dd035cdac811803d9d191',
-    entity_object: '0xb75b6953254cf9a426fb06b1ceb711784031cf7817b66630ba00daf5660ab04e',
+    package: "0xa5a2e79de613b6585a584dd9aee8f464a1a1f2826fefc656f44e95ee3c60d673",
+    wowok_object: '0x4723d6660029b1d1a70d6ebb7bfed4b3f06c7e811d6b9845b41d7451555fee02',
+    entity_object: '0xb91ae0f0e38f205c7d4f90639fa0bd6fc6448889f8de38547dd6fb29304fc89b',
 }
 
 const MAINNET = {
@@ -206,6 +206,7 @@ export interface CoinTypeInfo {
     symbol: string;
     type: string;
     decimals: number;
+    alias ?: boolean;
 }
 export class Protocol {
     protected network = '';
@@ -252,7 +253,7 @@ export class Protocol {
                 break;
         };
     }
-    Package(): string { return this.package }
+        Package(): string { return this.package }
     WowokObject(): string { return this.wowok_object }
     EntityObject(): string { return this.entity_object }
     GraphqlUrl() : string { return this.graphql }
@@ -334,9 +335,9 @@ export class Protocol {
     COINS_TYPE = () => { 
         switch(this.network) {
             case ENTRYPOINT.testnet:
-                return this.CoinTypes_Testnet;
+                return this.CoinTypes_Testnet.filter((v)=>v.alias !== true);
             case ENTRYPOINT.mainnet:
-                return this.CoinTypes_Mainnet;
+                return this.CoinTypes_Mainnet.filter((v)=>v.alias !== true);
         }; return [];
     }
     Update_CoinType = (token_type: string, decimals:number, symbol: string) => {
@@ -363,8 +364,14 @@ export class Protocol {
     }
 
     CoinTypes_Testnet:CoinTypeInfo[] = [
-        {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9},
-        {symbol:'SUI', type:'0x2::sui::SUI', decimals:9},
+        {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
+        {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
+        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+    ];
+
+    CoinTypes_Mainnet:CoinTypeInfo[] = [
+        {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
+        {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
         {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
         {symbol:'USDT', type:'0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN', decimals:6},
         {symbol:'USDC', type:'0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN', decimals:6},              
@@ -372,10 +379,8 @@ export class Protocol {
         {symbol:'WBNB', type:'0xb848cce11ef3a8f62eccea6eb5b35a12c4c2b1ee1af7755d02d7bd6218e8226f::coin::COIN', decimals:8},
     ];
 
-    CoinTypes_Mainnet:CoinTypeInfo[] = [
-    ];
-
     GetCoinTypeInfo = (token_type: string, handler:(info:CoinTypeInfo)=>void) : CoinTypeInfo | 'loading' => {
+        if (!token_type) return 'loading';
         let r = this.COINS_TYPE().find((v) => v?.type === token_type);
         if (!r) {
             Protocol.Client().getCoinMetadata({coinType:token_type}).then((res) => {

package/src/repository.ts

@@ -254,14 +254,14 @@ export class Repository {
             this.txb.moveCall({
                 target:Protocol.Instance().RepositoryFn('policy_remove_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    this.txb.pure.vector('string', array_unique(policy_keys)), 
                     Protocol.TXB_OBJECT(this.txb, this.permission)]
             })                
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().RepositoryFn('policy_remove') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    this.txb.pure.vector('string', array_unique(policy_keys)), 
                     Protocol.TXB_OBJECT(this.txb, this.permission)]
             })                     
         }

package/src/resource.ts

@@ -3,15 +3,15 @@ import { IsValidDesription, IsValidAddress, IsValidName, IsValidArray,  } from '
 import { ERROR, Errors } from './exception';
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
-export interface Tags {
-    address: string;
-    nick: string;
-    tags: string[];
+export interface Tags { // tag am address
+    address: string; // address to tag
+    nick: string; //  named address
+    tags: string[]; // tags for address
 }
 
-export interface ResourceData {
-    name: string;
-    address: string[];
+export interface ResourceData { // personal folder
+    name: string; // folder name
+    address: string[]; // objects in folder
 }
 
 export class Resource {

package/src/service.ts

@@ -1,10 +1,11 @@
 import { IsValidArray, IsValidPercent, IsValidName_AllowEmpty, Bcs, array_unique, IsValidTokenType, IsValidDesription, 
-    IsValidAddress, IsValidEndpoint, IsValidUintLarge, IsValidInt, IsValidName, } from './utils'
+    IsValidAddress, IsValidEndpoint, IsValidU64, IsValidName,} from './utils'
 import { FnCallType, GuardObject, PassportObject, PermissionObject, RepositoryObject, MachineObject, ServiceAddress, 
     ServiceObject, DiscountObject, OrderObject, OrderAddress, CoinObject, Protocol, ValueType,
     TxbObject} from './protocol';
 import { ERROR, Errors } from './exception';
-import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
+import { Transaction as TransactionBlock,  } from '@mysten/sui/transactions';
+import { SuiObjectData } from '@mysten/sui/client';
 
 export type Service_Guard_Percent = {
     guard:GuardObject;
@@ -12,8 +13,8 @@ export type Service_Guard_Percent = {
 }
 export type Service_Sale = {
     item:string;
-    price:number;
-    stock:number;
+    price:bigint;
+    stock:bigint;
     endpoint?:string;
 }
 export enum Service_Discount_Type {
@@ -26,7 +27,7 @@ export type Service_Discount = {
     off: number;
     duration_minutes: number;
     time_start?: number; // current time if undefined
-    price_greater?: number;
+    price_greater?: bigint;
 }
 
 export type Service_Buy_RequiredInfo = {
@@ -47,16 +48,17 @@ export enum BuyRequiredEnum {
 
 export type Service_Buy = {
     item: string;
-    max_price: number;
-    count: number;
+    max_price: bigint;
+    count: bigint;
 }
 
 export type DicountDispatch = {
     receiver: string;
-    count: number;
+    count: bigint;
     discount: Service_Discount;
 }
 
+export type handleDiscountObject = (owner:string, objects:(SuiObjectData|null|undefined)[]) => void;
 export class Service {
     protected pay_token_type;
     protected permission;
@@ -152,9 +154,9 @@ export class Service {
             })
         }
     }
-    set_price(item:string, price:number, bNotFoundAssert:boolean=true, passport?:PassportObject) {
-        if (!IsValidInt(price)) {
-            ERROR(Errors.IsValidInt, 'price')
+    set_price(item:string, price:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject) {
+        if (!IsValidU64(price)) {
+            ERROR(Errors.IsValidU64, 'price')
         } 
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
@@ -178,12 +180,12 @@ export class Service {
             })
         }
     }
-    set_stock(item:string, stock:number, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
+    set_stock(item:string, stock:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
         }
-        if (!IsValidInt(stock)) {
-            ERROR(Errors.IsValidInt, 'stock')
+        if (!IsValidU64(stock)) {
+            ERROR(Errors.IsValidU64, 'stock')
         }
         
         if (passport) {
@@ -204,11 +206,11 @@ export class Service {
             })
         }
     }
-    add_stock(item:string, stock_add:number, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
+    add_stock(item:string, stock_add:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
         }
-        if (!IsValidUintLarge(stock_add)) {
+        if (!IsValidU64(stock_add)) {
             ERROR(Errors.IsValidUint, 'stock_add')
         }
         
@@ -230,11 +232,11 @@ export class Service {
             })        
         }
     }
-    reduce_stock(item:string, stock_reduce:number, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
+    reduce_stock(item:string, stock_reduce:bigint, bNotFoundAssert:boolean=true, passport?:PassportObject)  {
         if (!IsValidName(item)) {
             ERROR(Errors.IsValidName, 'item')
         }
-        if (!IsValidUintLarge(stock_reduce)) {
+        if (!IsValidU64(stock_reduce)) {
             ERROR(Errors.IsValidUint, 'stock_reduce')
         }
 
@@ -505,8 +507,8 @@ export class Service {
         let bValid = true; let names:string[]  = [];
         sales.forEach((v) => {
             if (!IsValidName(v.item)) bValid = false;
-            if (!IsValidInt(v.price)) bValid = false;
-            if (!IsValidUintLarge(v.stock)) bValid = false;
+            if (!IsValidU64(v.price)) bValid = false;
+            if (!IsValidU64(v.stock)) bValid = false;
             if (names.includes(v.item)) bValid = false;
             names.push(v.item)
         })
@@ -520,7 +522,7 @@ export class Service {
             ERROR(Errors.InvalidParam, 'add_sales')
         }
         
-        let names: string[]  = []; let price: number[] = []; let stock: number[] = []; let endpoint: string[] = [];
+        let names: string[]  = []; let price: bigint[] = []; let stock: bigint[] = []; let endpoint: string[] = [];
         sales.forEach((s) => {
             if (s.endpoint && !IsValidEndpoint(s.endpoint)) {
                 ERROR(Errors.IsValidEndpoint, 'add_sales')
@@ -531,24 +533,26 @@ export class Service {
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('sales_add_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, names)), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, endpoint)), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_BOOL, bExistAssert)),
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', names), 
+                    this.txb.pure.vector('string', endpoint),
+                    this.txb.pure.vector('u64', price), this.txb.pure.vector('u64', stock), 
+                    this.txb.pure.bool(bExistAssert),                    
                     Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('sales_add') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, names)), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, endpoint)),
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_BOOL, bExistAssert)),
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', names), 
+                    this.txb.pure.vector('string', endpoint),
+                    this.txb.pure.vector('u64', price), this.txb.pure.vector('u64', stock), 
+                    this.txb.pure.bool(bExistAssert),
                     Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })
         }
     }
+
     remove_sales(sales:string[], passport?:PassportObject) {
         if (sales.length === 0) return;
 
@@ -559,14 +563,14 @@ export class Service {
         if (passport) {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('sales_remove_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
+                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', array_unique(sales!)),  
                     Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })            
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('sales_remove') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(sales!))), 
+                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', array_unique(sales!)), 
                     Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })            
@@ -581,12 +585,12 @@ export class Service {
         let bValid = true;
         discount_dispatch.forEach((v) => {
             if (!IsValidAddress(v.receiver)) bValid = false;
-            if (!IsValidUintLarge(v.count) || v.count > Service.MAX_DISCOUNT_COUNT_ONCE) bValid = false;
+            if (!IsValidU64(v.count) || v.count > Service.MAX_DISCOUNT_COUNT_ONCE) bValid = false;
             if (!IsValidName_AllowEmpty(v.discount.name)) bValid = false;
             if (v.discount.type == Service_Discount_Type.ratio && !IsValidPercent(v.discount.off)) bValid = false;
-            if (!IsValidUintLarge(v.discount.duration_minutes)) bValid = false;
-            if (v.discount?.time_start && !IsValidUintLarge(v.discount.time_start)) bValid = false;
-            if (v.discount?.price_greater && !IsValidInt(v.discount.price_greater))  bValid = false;
+            if (!IsValidU64(v.discount.duration_minutes)) bValid = false;
+            if (v.discount?.time_start && !IsValidU64(v.discount.time_start)) bValid = false;
+            if (v.discount?.price_greater && !IsValidU64(v.discount.price_greater))  bValid = false;
         })
         if (!bValid) {
             ERROR(Errors.InvalidParam, 'discount_dispatch')
@@ -741,28 +745,25 @@ export class Service {
         }      
         
     }
-    clone(passport?:PassportObject) : ServiceObject  {
+    clone(new_token_type?:string, passport?:PassportObject) : ServiceObject  {
         if (passport) {
             return this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('clone_withpassport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.pay_token_type]
+                typeArguments:[this.pay_token_type, new_token_type ? new_token_type : this.pay_token_type]
             })    
         } else {
             return this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('clone') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.pay_token_type]
+                typeArguments:[this.pay_token_type, new_token_type ? new_token_type : this.pay_token_type]
             })    
         }  
     }
 
     set_customer_required(pubkey:string, customer_required: BuyRequiredEnum[], passport?:PassportObject) {
-        if (!pubkey) {
+        if(customer_required.length > 0 && !pubkey) {
             ERROR(Errors.InvalidParam, 'pubkey')
-        } 
-        if(!customer_required) {
-            ERROR(Errors.InvalidParam, 'customer_required')
         }
 
         let req = array_unique(customer_required) as string[];
@@ -771,7 +772,7 @@ export class Service {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('required_set_with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, req)), 
+                    this.txb.pure.vector('string', req),
                     this.txb.pure.string(pubkey), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })         
@@ -779,7 +780,7 @@ export class Service {
             this.txb.moveCall({
                 target:Protocol.Instance().ServiceFn('required_set') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, req)), 
+                    this.txb.pure.vector('string', req),
                     this.txb.pure.string(pubkey), Protocol.TXB_OBJECT(this.txb, this.permission)],
                 typeArguments:[this.pay_token_type]
             })         
@@ -894,7 +895,7 @@ export class Service {
             arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, order), 
                 this.txb.pure.string(customer_info_crypto.pubkey), 
                 this.txb.pure.string(customer_info_crypto.customer_pubkey), 
-                this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_VEC_U8, array_unique(customer_info_crypto.customer_info_crypt)))],
+                this.txb.pure.vector('vector<u8>', array_unique(customer_info_crypto.customer_info_crypt))],
             typeArguments:[this.pay_token_type]
         })    
         
@@ -909,8 +910,8 @@ export class Service {
         let bValid = true; let names:string[]  = [];
         buy_items.forEach((v) => {
             if (!IsValidName(v.item)) bValid = false;
-            if (!IsValidInt(v.max_price)) bValid = false;
-            if (!IsValidUintLarge(v.count)) bValid = false;
+            if (!IsValidU64(v.max_price)) bValid = false;
+            if (!IsValidU64(v.count)) bValid = false;
             if (names.includes(v.item)) bValid = false;
             names.push(v.item)
         })
@@ -918,42 +919,45 @@ export class Service {
             ERROR(Errors.InvalidParam, 'buy_items 2')
         }
 
-        let name:string[] = []; let price:number[] = [];    let stock:number[] = []; let order;
+        let name:string[] = []; let price:bigint[] = [];    let stock:bigint[] = []; let order;
         buy_items.forEach((b) => { name.push(b.item); price.push(b.max_price); stock.push(b.count)})
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
         if (passport) {
             if (discount) {
+                console.log(1)
                 order = this.txb.moveCall({
                     target:Protocol.Instance().ServiceFn('dicount_buy_with_passport') as FnCallType,
-                    arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, name)), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                    arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name), 
+                        this.txb.pure.vector('u64', price), this.txb.pure.vector('u64', stock), 
                         Protocol.TXB_OBJECT(this.txb, coin), Protocol.TXB_OBJECT(this.txb, discount), this.txb.object(clock)],                   
                     typeArguments:[this.pay_token_type]            
             })} else {
+                console.log(2)
                 order = this.txb.moveCall({
                     target:Protocol.Instance().ServiceFn('buy_with_passport') as FnCallType,
-                    arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, name)), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                    arguments: [passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name), 
+                        this.txb.pure.vector('u64', price), this.txb.pure.vector('u64', stock), 
                         Protocol.TXB_OBJECT(this.txb, coin)],
                     typeArguments:[this.pay_token_type]            
             })}             
         } else {
+            console.log(3)
             if (discount) {
                 order = this.txb.moveCall({
                     target:Protocol.Instance().ServiceFn('disoucnt_buy') as FnCallType,
                     arguments: [Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                        this.txb.pure.vector('u64', price), 
+                        this.txb.pure.vector('u64', stock), 
                         Protocol.TXB_OBJECT(this.txb, coin), 
                         Protocol.TXB_OBJECT(this.txb, discount), this.txb.object(clock)],                
                     typeArguments:[this.pay_token_type]            
             })} else {
+                console.log(4)
                 order = this.txb.moveCall({
                     target:Protocol.Instance().ServiceFn('buy') as FnCallType,
                     arguments: [Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.vector('string', name), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, price)), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_U64, stock)), 
+                        this.txb.pure.vector('u64', price), 
+                        this.txb.pure.vector('u64', stock), 
                         Protocol.TXB_OBJECT(this.txb, coin)],
                     typeArguments:[this.pay_token_type]            
             })}           
@@ -1025,5 +1029,13 @@ export class Service {
             return service_endpoint + '/sales/' + encodeURI(item_name);
         }
     }
-
+    static DiscountObjects = (owner:string, handleDiscountObject:handleDiscountObject) => {
+        Protocol.Client().getOwnedObjects({owner:owner, 
+            filter:{MoveModule:{module:'order', package:Protocol.Instance().Package()}}, 
+            options:{showContent:true, showType:true}}).then((res) => {
+            handleDiscountObject(owner, res.data.map((v)=>v.data));
+        }).catch((e) => {
+            console.log(e);
+        })       
+    }
 }

package/src/utils.ts

@@ -173,6 +173,12 @@ export class Bcs {
             'discord': BCS.STRING,
             'homepage': BCS.STRING,
         })
+        this.bcs.registerStructType('OptionAddress', {
+            'address': 'Option<address>',
+        })
+        this.bcs.registerStructType('Guards', {
+            'guards':'vector<OptionAddress>',
+        })
     }
     static getInstance() : Bcs { 
         if (!Bcs._instance) {
@@ -254,7 +260,6 @@ export class Bcs {
             case ValueType.TYPE_U64:
                 return this.bcs.de(BCS.U64, data);
             case ValueType.TYPE_U8:
-                console.log(data)
                 return this.bcs.de(BCS.U8, data);
             case ValueType.TYPE_VEC_U8:
                 return this.bcs.de('vector<u8>', data);
@@ -297,7 +302,8 @@ export class Bcs {
         }
     }
 
-    de_ent(data:Uint8Array) : any {
+    de_ent(data:Uint8Array | undefined) : any {
+        if (!data || data.length < 2) return ''
         const struct_vec = this.bcs.de('vector<u8>', data);
         return this.bcs.de('EntStruct', Uint8Array.from(struct_vec));
 /*        const reader = new BcsReader(data);
@@ -321,6 +327,14 @@ export class Bcs {
         r.description = new TextDecoder().decode(Uint8Array.from(r.description));
         return r
     }        
+    de_guards(data:Uint8Array | undefined) : any {
+        if (!data || data.length  < 1) return ''
+        let r = this.bcs.de('Guards', data);
+        return r?.guards?.map((v:any) => {
+            if (v?.address?.none) return undefined;
+            return v?.address?.some;
+        })
+    }   
 }
 
 export function stringToUint8Array(str:string) : Uint8Array {
@@ -374,35 +388,40 @@ export const MAX_ENDPOINT_LENGTH = 1024;
 export const IsValidDesription = (description:string) : boolean => { return description?.length <= MAX_DESCRIPTION_LENGTH }
 export const IsValidName = (name:string) : boolean => { if(!name) return false; return name.length <= MAX_NAME_LENGTH && name.length != 0 }
 export const IsValidName_AllowEmpty = (name:string) : boolean => { return name.length <= MAX_NAME_LENGTH }
-export const IsValidEndpoint = (endpoint:string) : boolean => { if (!endpoint) return false; return endpoint.length <= MAX_ENDPOINT_LENGTH }
+export const IsValidEndpoint = (endpoint:string) : boolean => { 
+    return (endpoint.length > 0 && endpoint.length <= MAX_ENDPOINT_LENGTH && isValidHttpUrl(endpoint)) ;
+}
 export const IsValidAddress = (addr:string | undefined) : boolean => { 
     if (!addr || !isValidSuiAddress(addr)) {
         return false; 
     }
     return true
 }
-export const IsValidBigint = (value:string | number | undefined, max:bigint=MAX_U256) : boolean => {
+export const IsValidBigint = (value:string | number | undefined | bigint, max:bigint=MAX_U256, min?:bigint) : boolean => {
     if (value === '' || value === undefined) return false;
     try {
         const v = BigInt(value);
         if (v <= max) {
+            if (min !== undefined) {
+                return v >= min;
+            }
             return true   
         }
     } catch (e) {
     }; return false
 }
 
-export const IsValidUintLarge = (value:string | number | undefined) : boolean => {
-    return IsValidBigint(value)
+export const IsValidUintLarge = (value:string | number | undefined | bigint) : boolean => {
+    return IsValidBigint(value, MAX_U64, BigInt(0))
 }
-export const IsValidU8 = (value:string | number | undefined) : boolean => {
-    return IsValidBigint(value, MAX_U8)
+export const IsValidU8 = (value:string | number | undefined | bigint) : boolean => {
+    return IsValidBigint(value, MAX_U8, BigInt(0))
 }
-export const IsValidU64 = (value:string | number | undefined) : boolean => {
-    return IsValidBigint(value, MAX_U64)
+export const IsValidU64 = (value:string | number | undefined | bigint) : boolean => {
+    return IsValidBigint(value, MAX_U64, BigInt(0))
 }
-export const IsValidU128 = (value:string | number | undefined) : boolean => {
-    return IsValidBigint(value, MAX_U128)
+export const IsValidU128 = (value:string | number | undefined | bigint) : boolean => {
+    return IsValidBigint(value, MAX_U128, BigInt(0))
 }
 
 export const IsValidTokenType = (argType: string) : boolean => { 
@@ -434,14 +453,12 @@ export const IsValidInt = (value: number | string) : boolean => {
     }
     return Number.isSafeInteger(value) 
 }
-export const IsValidPercent = (value: number | string) : boolean => { 
-    if (typeof(value) === 'string') {
-        value = parseInt(value as string);
-    }
-    return Number.isSafeInteger(value) && value > 0 && value <= 100 
+export const IsValidPercent = (value: number | string | bigint) : boolean => { 
+    return IsValidBigint(value, BigInt(100), BigInt(0))
 }
-export const IsValidArray = (arr: any[], validFunc:any) : boolean => {
-    for (let i = 0; i < arr.length; ++i) {
+
+export const IsValidArray = (arr: any, validFunc:any) : boolean => {
+    for (let i = 0; i < arr.length; i++) {
         if (!validFunc(arr[i])) {
             return false
         }

package/src/vote.ts

@@ -229,7 +229,7 @@ export class Vote {
                 this.txb.moveCall({
                     target:Protocol.Instance().VoteFn('agrees_remove_with_passport') as FnCallType,
                     arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options))), 
+                        this.txb.pure.vector('string', array_unique(options)), 
                         Protocol.TXB_OBJECT(this.txb, this.permission)]
                 })             
             }
@@ -243,7 +243,7 @@ export class Vote {
                 this.txb.moveCall({
                     target:Protocol.Instance().VoteFn('agrees_remove') as FnCallType,
                     arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                        this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options))), 
+                        this.txb.pure.vector('string', array_unique(options)),  
                         Protocol.TXB_OBJECT(this.txb, this.permission)]
                 })        
             }
@@ -341,13 +341,13 @@ export class Vote {
             this.txb.moveCall({
                 target:Protocol.Instance().VoteFn('with_passport') as FnCallType,
                 arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options)))]
+                    this.txb.pure.vector('string', array_unique(options))]
             })  
         } else {
             this.txb.moveCall({
                 target:Protocol.Instance().VoteFn('this.object') as FnCallType,
                 arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options)))]
+                    this.txb.pure.vector('string', array_unique(options))]
             })           
         }
     }