wowok 1.0.6 → 1.0.8

package/src/passport.ts

@@ -1,36 +1,62 @@
 import { SuiObjectResponse, SuiObjectDataOptions } from '@mysten/sui.js/client';
-import { TransactionBlock, TransactionResult, type TransactionObjectInput, Inputs } from '@mysten/sui.js/transactions';
-import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, PassportObject, GuardObject, TXB_OBJECT} from './protocol';
-import { parse_object_type, array_unique } from './utils';
-import { rpc_sense_objects_fn } from './guard';
+import { TransactionBlock, TransactionResult, type TransactionObjectInput, Inputs, TransactionArgument } from '@mysten/sui.js/transactions';
+import { PROTOCOL, FnCallType, CLOCK_OBJECT, Query_Param, OBJECTS_TYPE, OBJECTS_TYPE_PREFIX, PassportObject, GuardObject, 
+    TXB_OBJECT, ContextType, IsValidAddress, IsValidArray, IsValidObjects} from './protocol';
+import { parse_object_type, array_unique, BCS_CONVERT } from './utils';
+import { rpc_sense_objects_fn, parse_sense_bsc, parse_futures, FutureValueRequest, VariableType, add_variable, add_future_variable} from './guard';
+import { BCS } from '@mysten/bcs';
 
 export const MAX_GUARD_COUNT = 8;
 
+// from guards: get future objects to fill by singer 
+export const guard_futures = async (guards:string[]) : Promise<FutureValueRequest[]> => {
+    let futrue_objects = guards.map((value) => {
+        return {objectid:value, callback:rpc_sense_objects_fn, parser:parse_futures, data:[]} as Query_Param
+    });
+    await PROTOCOL.Query(futrue_objects); // future objects
+    let future_objects_result:FutureValueRequest[] = [];
+    futrue_objects.forEach((futrue) => { 
+        futrue.data.forEach((f:FutureValueRequest) => {
+            if (future_objects_result.findIndex((v)=>{ return v.guardid == f.guardid && v.identifier == f.identifier}) ==  -1) {
+                future_objects_result.push(f);
+            }
+        }) ;
+    });
+
+    return future_objects_result
+}
+
+// from guards: get objects to 'guard_query' on chain , with future variables had filled.
 // passport verify for some guards, MUST be in ONE pxb:
 // 0. construct Guard_Query_Objects(passport_quries) from queries for guards of objects
 // 1. create passport
-// 2. add all guards
+// 2. add all guards / guards future variables
 // 3. verify passport
 // 4. ops using passport(guard set on object)
 // 5. ops using passport(guard set on object)
 // 6. destroy passport
-
-
-export const passport_queries = async (guards:string[]) : Promise<Guard_Query_Object[]> => {
+export const guard_queries = async (guards:string[], futures?:FutureValueRequest[]) : Promise<Guard_Query_Object[]> => {
     let sense_objects = guards.map((value) => {
-        return {objectid:value, callback:rpc_sense_objects_fn, data:[]} as Query_Param
+        let v:VariableType = new Map();
+        futures?.forEach((f) => {
+            if (f.guardid == value) {   
+                add_future_variable(v, f.identifier, f.type, f.witness.slice(0), f?.value?f.value.slice(0):undefined, true);
+            } 
+        })
+        return {objectid:value, callback:rpc_sense_objects_fn, parser:parse_sense_bsc, data:[], variables:futures?v:undefined} as Query_Param
     });
+
     await PROTOCOL.Query(sense_objects); // objects need quering in guards
     let sense_objects_result:string[] = [];
     sense_objects.forEach((value) => { // DONT CHANGE objects sequence 
         sense_objects_result = sense_objects_result.concat(value.data);
     });
     sense_objects_result = array_unique(sense_objects_result); // objects in guards
-    // console.log(sense_objects_result);
-
+    
     let queries = sense_objects_result.map((value) => { 
         return {objectid:value, callback:rpc_query_cmd_fn, data:[]} as Query_Param;
     })
+
     await PROTOCOL.Query(queries, {'showType':true}); // queries for passport verifing
     let res : Guard_Query_Object[] = [];
     sense_objects.forEach((guard) => { // DONT CHANGE objects sequence  for passport verifying
@@ -51,40 +77,47 @@ export const passport_queries = async (guards:string[]) : Promise<Guard_Query_Ob
 }
 
 // return passport object used
-export function verify(txb:TransactionBlock, guards:string[], passport_queries:Guard_Query_Object[]) : PassportObject | boolean {
-    if (!guards || passport_queries.length == 0 || passport_queries.length > MAX_GUARD_COUNT) {
-        return false;
-    }
-    
+export function verify(txb:TransactionBlock, guards:GuardObject[], guard_queries:Guard_Query_Object[], future_values?:FutureValueRequest[]) : PassportObject | boolean {
+    if (!guards || guards.length > MAX_GUARD_COUNT)   return false;
+    if (!IsValidObjects(guards)) return false;
+
     var passport = txb.moveCall({
         target: PROTOCOL.PassportFn('new') as FnCallType,
-        arguments: [ TXB_OBJECT(txb, guards[0]), txb.object(CLOCK_OBJECT)]
+        arguments: []
     });
-
+   
     // add others guards, if any
-    for (let i = 1; i < guards.length; i++) {
+    guards.forEach((guard) => {
         txb.moveCall({
             target:PROTOCOL.PassportFn('guard_add') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, guards[i])]
-        });
-    }
+            arguments:[passport, TXB_OBJECT(txb, guard)]
+        });        
+    })
 
-    // rules: 'verify' & 'query' in turns；'verify' at final end.
-    for (let i = 0; i < passport_queries.length; i++) {
+    future_values?.forEach((v) => {
         txb.moveCall({
+            target:PROTOCOL.PassportFn('future_set') as FnCallType,
+            arguments:[passport, txb.pure(BCS_CONVERT.ser_address(v.guardid)), txb.pure(BCS_CONVERT.ser_u8(v.identifier)), 
+                txb.pure(BCS_CONVERT.ser_address(v.value!))]
+        })
+    })
+
+    // rules: 'verify' & 'query' in turns；'verify' at final end.
+    for (let i = 0; i < guard_queries.length; i++) {
+        let res = txb.moveCall({
             target: PROTOCOL.PassportFn('passport_verify') as FnCallType,
-            arguments: [ passport ]
+            arguments: [ passport, txb.object(CLOCK_OBJECT),  ]
         }); 
         txb.moveCall({
-            target: passport_queries[i].target as FnCallType,
-            arguments: [ txb.object(passport_queries[i].object), passport ],
-            typeArguments: passport_queries[i].types,
+            target: guard_queries[i].target as FnCallType,
+            arguments: [ txb.object(guard_queries[i].object), passport, res ],
+            typeArguments: guard_queries[i].types,
         })
-    }
+    } 
     txb.moveCall({
         target: PROTOCOL.PassportFn('passport_verify') as FnCallType,
-        arguments: [ passport ]
-    });     
+        arguments: [ passport,  txb.object(CLOCK_OBJECT) ]
+    });   
 
     return passport;
 }

package/src/progress.ts

@@ -55,13 +55,13 @@ export function progress_set_namedOperator(txb:TransactionBlock, machine:Machine
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('namedOperator_set_with_passport') as FnCallType,
-            arguments: [passport, TXB_OBJECT(txb, progress), txb.pure(name), txb.pure(array_unique(addresses), 'vector<address>'), 
+            arguments: [passport, TXB_OBJECT(txb, progress), txb.pure(name, BCS.STRING), txb.pure(array_unique(addresses), 'vector<address>'), 
             TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })  
     } else {
         txb.moveCall({
             target:PROTOCOL.ProgressFn('namedOperator_set') as FnCallType,
-            arguments: [TXB_OBJECT(txb, progress), txb.pure(name), txb.pure(array_unique(addresses), 'vector<address>'), 
+            arguments: [TXB_OBJECT(txb, progress), txb.pure(name, BCS.STRING), txb.pure(array_unique(addresses), 'vector<address>'), 
             TXB_OBJECT(txb, machine), TXB_OBJECT(txb, permission)],
         })  
     }  

package/src/protocol.ts

@@ -4,18 +4,19 @@ import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
 import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
 import { TransactionBlock, Inputs, type TransactionResult, type TransactionArgument } from '@mysten/sui.js/transactions';
 import { capitalize } from './utils'
+import { VariableType } from './guard';
 
 export const MAX_DESCRIPTION_LENGTH = 1024;
 export const MAX_NAME_LENGTH = 64;
 export const MAX_ENDPOINT_LENGTH = 1024;
 export const OptionNone = (txb:TransactionBlock) : TransactionArgument => { return txb.pure([], BCS.U8) };
 
-export const IsValidDesription = (description:string) : boolean => { return description.length <= MAX_DESCRIPTION_LENGTH }
-export const IsValidName = (name:string) : boolean => { return name.length <= MAX_NAME_LENGTH && name.length != 0 }
+export const IsValidDesription = (description:string) : boolean => { if (!description) return false; 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 => { return endpoint.length <= MAX_ENDPOINT_LENGTH }
-export const IsValidAddress = (address:string) : boolean => { return address.length != 0 }
-export const IsValidArgType = (argType: string) : boolean => { return argType.length != 0 }
+export const IsValidEndpoint = (endpoint:string) : boolean => { if (!endpoint) return false; return endpoint.length <= MAX_ENDPOINT_LENGTH }
+export const IsValidAddress = (addr:string) : boolean => { if (!addr) return false; return true}
+export const IsValidArgType = (argType: string) : boolean => { if (!argType) return false; return argType.length != 0 }
 export const IsValidUint = (value: number) : boolean => { return Number.isSafeInteger(value) && value != 0 }
 export const IsValidInt = (value: number) : boolean => { return Number.isSafeInteger(value) }
 export const IsValidPercent = (value: number) : boolean => { return Number.isSafeInteger(value) && value > 0 && value <= 100 }
@@ -57,7 +58,7 @@ export type PermissionObject = TransactionResult | string;
 export type RepositoryAddress = TransactionResult;
 export type RepositoryObject = TransactionResult | string;
 export type GuardAddress = TransactionResult;
-export type GuardObject = TransactionResult | string;
+export type GuardObject = TransactionResult | string ;
 export type MachineAddress = TransactionResult;
 export type MachineObject = TransactionResult | string;
 export type PassportObject = TransactionResult;
@@ -92,13 +93,51 @@ export const CLOCK_OBJECT = Inputs.SharedObjectRef({
     initialSharedVersion: 1,
 });
 
+export enum OperatorType {
+    TYPE_QUERY = 1, // query wowok object
+    TYPE_FUTURE_QUERY = 2,
+    TYPE_QUERY_FROM_CONTEXT = 3, 
+
+    TYPE_LOGIC_OPERATOR_U128_GREATER = 11,
+    TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL = 12,
+    TYPE_LOGIC_OPERATOR_U128_LESSER = 13,
+    TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL = 14,
+    TYPE_LOGIC_OPERATOR_U128_EQUAL = 15,
+    TYPE_LOGIC_OPERATOR_EQUAL = 16, // TYPE&DATA(vector<u8>) MUST BE EQUAL
+    TYPE_LOGIC_OPERATOR_HAS_SUBSTRING = 17, // SUBSTRING
+    TYPE_LOGIC_ALWAYS_TRUE = 18, // aways true
+}
+
+export enum ContextType {
+    TYPE_CONTEXT_SIGNER  = 60,
+    TYPE_CONTEXT_CLOCK = 61,
+    TYPE_CONTEXT_FUTURE_ID = 62, 
+    
+    TYPE_CONTEXT_bool = 70,
+    TYPE_CONTEXT_address = 71,
+    TYPE_CONTEXT_u64 = 72,
+    TYPE_CONTEXT_u8 = 73,
+    TYPE_CONTEXT_vec_u8 = 74,
+ /*   TYPE_CONTEXT_u128 = 75,
+    TYPE_CONTEXT_vec_address = 76,
+    TYPE_CONTEXT_vec_bool = 77,
+    TYPE_CONTEXT_vec_vec_u8 = 78,
+    TYPE_CONTEXT_vec_u64 = 79,
+    TYPE_CONTEXT_vec_u128 = 80,
+    TYPE_CONTEXT_option_address = 81,
+    TYPE_CONTEXT_option_bool = 82,
+    TYPE_CONTEXT_option_u8 = 83,
+    TYPE_CONTEXT_option_u64 = 84,
+    TYPE_CONTEXT_option_u128 = 85,*/
+}
+
 export enum ValueType {
     TYPE_STATIC_bool = 100,
     TYPE_STATIC_address = 101,
     TYPE_STATIC_u64 = 102,
     TYPE_STATIC_u8 = 103,
-    TYPE_STATIC_u128 = 104,
-    TYPE_STATIC_vec_u8 = 105,
+    TYPE_STATIC_vec_u8 = 104,
+    TYPE_STATIC_u128 = 105,
     TYPE_STATIC_vec_address = 106,
     TYPE_STATIC_vec_bool = 107,
     TYPE_STATIC_vec_vec_u8 = 108,
@@ -111,24 +150,6 @@ export enum ValueType {
     TYPE_STATIC_option_u128 = 115,
 }
 
-export enum OperatorType {
-    TYPE_DYNAMIC_QUERY = 1, // query wowok object
-    TYPE_LOGIC_OPERATOR_U128_GREATER = 11,
-    TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL = 12,
-    TYPE_LOGIC_OPERATOR_U128_LESSER = 13,
-    TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL = 14,
-    TYPE_LOGIC_OPERATOR_U128_EQUAL = 15,
-    TYPE_LOGIC_OPERATOR_EQUAL = 16, // TYPE&DATA(vector<u8>) MUST BE EQUAL
-    TYPE_LOGIC_OPERATOR_HAS_SUBSTRING = 17, // SUBSTRING
-    TYPE_LOGIC_ALWAYS_TRUE = 18, // aways true
-}
-
-export enum ContextType {
-    TYPE_CONTEXT_SIGNER  = 60,
-    TYPE_CONTEXT_CURRENT_PROGRESS = 61,
-    TYPE_CONTEXT_CURRENT_CLOCK = 62,
-}
-
 export type Data_Type = ValueType | OperatorType | ContextType;
 
 export enum ENTRYPOINT {
@@ -159,7 +180,7 @@ export class Protocol {
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = "0x877375bc3bde063e4b95f428df218af7faaeef431993f4a68f2dfa5ceb8acb2e";
+                this.package = "0xf4233055f40a9f301c85c020496b58ad761fdd2cd6a5d82da7a912adb4608f7f";
                 this.everyone_guard = "0x78a41fcc4f566360839613f6b917fb101ae015e56b43143f496f265b6422fddc";
                 this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
@@ -224,7 +245,8 @@ export class Protocol {
         const response = await client.signAndExecuteTransactionBlock({
             transactionBlock: txb, 
             signer: keypair,
-            options
+            options,
+            
         });
         return response;
     }
@@ -233,7 +255,9 @@ export class Protocol {
 export type Query_Param = {
     objectid: string;
     callback: (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions)=>void;
+    parser?: (result:any[], guardid: string, chain_sense_bsc:Uint8Array, variable?:VariableType)  => boolean;
     data?: any; // response data filted by callback
+    variables?: VariableType;
 };
 export const PROTOCOL = new Protocol();
 export const SUI_TYPE = '0x2::coin::Coin<0x2::sui::SUI>';

package/src/service.ts

@@ -1,5 +1,5 @@
 import { TransactionBlock, type TransactionResult } from '@mysten/sui.js/transactions';
-import { BCS } from '@mysten/bcs'; 
+import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig } from '@mysten/bcs';
 import { BCS_CONVERT, array_unique } from './utils'
 import { CLOCK_OBJECT, FnCallType, GuardObject, PROTOCOL, PassportObject, PermissionObject,
     RepositoryObject, MachineObject, ServiceAddress, ServiceObject, IsValidObjects, IsValidArgType, IsValidDesription, 
@@ -72,7 +72,7 @@ export function service_set_description(pay_type:string, txb:TransactionBlock, s
     return true
 }
 export function service_set_price(pay_type:string, txb:TransactionBlock, service:ServiceObject, permission:PermissionObject, 
-    item:string, price:number, passport?:PassportObject) : boolean {
+    item:string, price:number, bNotFoundAssert:boolean=true, passport?:PassportObject) : boolean {
     if (!IsValidObjects([service, permission])) return false;
     if (!IsValidArgType(pay_type)) return false;
     if (!IsValidInt(price) || !IsValidName(item)) return false;
@@ -80,20 +80,22 @@ export function service_set_price(pay_type:string, txb:TransactionBlock, service
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('price_set_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(price, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(price, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('price_set') as FnCallType,
-            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(price, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(price, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     }
     return true
 }
 export function service_set_stock(pay_type:string, txb:TransactionBlock, service:ServiceObject, permission:PermissionObject, 
-    item:string, stock:number, passport?:PassportObject) : boolean {
+    item:string, stock:number, bNotFoundAssert:boolean=true, passport?:PassportObject) : boolean {
     if (!IsValidObjects([service, permission])) return false;
     if (!IsValidArgType(pay_type)) return false;
     if (!IsValidName(item) || !IsValidInt(stock)) return false;
@@ -101,53 +103,59 @@ export function service_set_stock(pay_type:string, txb:TransactionBlock, service
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_set_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_set') as FnCallType,
-            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     }
     return true
 }
 export function service_add_stock(pay_type:string, txb:TransactionBlock, service:ServiceObject, permission:PermissionObject, 
-    item:string, stock_add:number, passport?:PassportObject) : boolean {
+    item:string, stock_add:number, bNotFoundAssert:boolean=true, passport?:PassportObject) : boolean {
     if (!IsValidObjects([service, permission])) return false;
     if (!IsValidArgType(pay_type)) return false;
     if (!IsValidName(item) || !IsValidUint(stock_add)) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_add_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_add, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_add, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })  
     } else {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_add') as FnCallType,
-            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_add, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_add, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })        
     }
     return true
 }
 export function service_reduce_stock(pay_type:string, txb:TransactionBlock, service:ServiceObject, permission:PermissionObject, 
-    item:string, stock_reduce:number, passport?:PassportObject) : boolean {
+    item:string, stock_reduce:number, bNotFoundAssert:boolean=true, passport?:PassportObject) : boolean {
     if (!IsValidObjects([service, permission])) return false;
     if (!IsValidArgType(pay_type)) return false;
     if (!IsValidName(item) || !IsValidUint(stock_reduce)) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_reduce_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_reduce, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_reduce, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     } else {
         txb.moveCall({
             target:PROTOCOL.ServiceFn('stock_reduce') as FnCallType,
-            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_reduce, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[TXB_OBJECT(txb, service), txb.pure(item), txb.pure(stock_reduce, BCS.U64), 
+                txb.pure(bNotFoundAssert, BCS.BOOL), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
         })
     }
@@ -372,30 +380,44 @@ export type Service_Sale = {
     stock:number;
 }
 
-export function service_add_sale(pay_type:string, txb:TransactionBlock, service:ServiceObject, 
-    permission:PermissionObject, sales:Service_Sale[], passport?:PassportObject) : boolean {
-    if (!IsValidObjects([service, permission])) return false;
-    if (!IsValidArgType(pay_type)) return false;
-    let bValid = true;
+export function is_valid_sale(sales:Service_Sale[]) : boolean {
+    let bValid = true; let names:string[]  = [];
     sales.forEach((v) => {
         if (!IsValidName(v.item)) bValid = false;
         if (!IsValidInt(v.price)) bValid = false;
-        if (!IsValidInt(v.stock)) bValid = false;
+        if (!IsValidUint(v.stock)) bValid = false;
+        if (names.includes(v.item)) bValid = false;
+        names.push(v.item)
     })
+    return bValid
+}
+export function service_add_sale(pay_type:string, txb:TransactionBlock, service:ServiceObject, 
+    permission:PermissionObject, sales:Service_Sale[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([service, permission])) return false;
+    if (!IsValidArgType(pay_type)) return false;
+    if (!sales) return false;
+    let bValid = is_valid_sale(sales);
     if (!bValid) return false;
+    
+    let names: string[]  = []; let price: number[] = []; let stock: number[] = [];
+    sales.forEach((s) => {
+        names.push(s.item); price.push(s.price); stock.push(s.stock);
+    })
 
     if (passport) {
-        sales.forEach((sale) => txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.ServiceFn('sales_add_with_passport') as FnCallType,
-            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(sale.item), txb.pure(sale.price, BCS.U64), txb.pure(sale.stock, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[passport, TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(names)), 
+                txb.pure(BCS_CONVERT.ser_vector_u64(price)), txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
-        }))
+        })
     } else {
-        sales.forEach((sale) => txb.moveCall({
+        txb.moveCall({
             target:PROTOCOL.ServiceFn('sales_add') as FnCallType,
-            arguments:[TXB_OBJECT(txb, service), txb.pure(sale.item), txb.pure(sale.price, BCS.U64), txb.pure(sale.stock, BCS.U64), TXB_OBJECT(txb, permission)],
+            arguments:[TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(names)), 
+                txb.pure(BCS_CONVERT.ser_vector_u64(price)), txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, permission)],
             typeArguments:[pay_type]
-        }))
+        })
     }
     return true
 }
@@ -803,6 +825,7 @@ export function customer_refund(pay_type:string, txb:TransactionBlock, service:S
 }
 export type Service_Buy = {
     item: string;
+    max_price: number;
     count: number;
 }
 
@@ -828,42 +851,45 @@ export function buy(pay_type:string, txb:TransactionBlock, service:ServiceObject
     if (!IsValidArgType(pay_type)) return false;
     if (!buy_items) return false;
 
-    let bValid = true;
+    let bValid = true; let names:string[]  = [];
     buy_items.forEach((v) => {
         if (!IsValidName(v.item)) bValid = false;
+        if (!IsValidInt(v.max_price)) bValid = false;
         if (!IsValidUint(v.count)) bValid = false;
+        if (names.includes(v.item)) bValid = false;
+        names.push(v.item)
     })
     if (!bValid) return false;
 
-    let i:string[] = []; let c:number[] = [];    let order;
-    buy_items.forEach((item) => { i.push(item.item); c.push(item.count); })
+    let name:string[] = []; let price:number[] = [];    let stock:number[] = []; let order;
+    buy_items.forEach((b) => { name.push(b.item); price.push(b.max_price); stock.push(b.count)})
 
     if (passport) {
         if (discount) {
             order = txb.moveCall({
                 target:PROTOCOL.ServiceFn('dicount_buy_with_passport') as FnCallType,
-                arguments: [passport, TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(i)), 
-                    txb.pure(BCS_CONVERT.ser_vector_u64(c)), TXB_OBJECT(txb, coin), TXB_OBJECT(txb, discount), txb.object(CLOCK_OBJECT)],                   
+                arguments: [passport, TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(name)), txb.pure(BCS_CONVERT.ser_vector_u64(price)), 
+                    txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, coin), TXB_OBJECT(txb, discount), txb.object(CLOCK_OBJECT)],                   
                 typeArguments:[pay_type]            
         })} else {
             order = txb.moveCall({
                 target:PROTOCOL.ServiceFn('buy_with_passport') as FnCallType,
-                arguments: [passport, TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(i)), 
-                    txb.pure(BCS_CONVERT.ser_vector_u64(c)), TXB_OBJECT(txb, coin)],
+                arguments: [passport, TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(name)), txb.pure(BCS_CONVERT.ser_vector_u64(price)), 
+                    txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, coin)],
                 typeArguments:[pay_type]            
         })}             
     } else {
         if (discount) {
             order = txb.moveCall({
                 target:PROTOCOL.ServiceFn('disoucnt_buy') as FnCallType,
-                arguments: [TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(i)), 
-                    txb.pure(BCS_CONVERT.ser_vector_u64(c)), TXB_OBJECT(txb, coin), TXB_OBJECT(txb, discount), txb.object(CLOCK_OBJECT)],                
+                arguments: [TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(name)), txb.pure(BCS_CONVERT.ser_vector_u64(price)), 
+                    txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, coin), TXB_OBJECT(txb, discount), txb.object(CLOCK_OBJECT)],                
                 typeArguments:[pay_type]            
         })} else {
             order = txb.moveCall({
                 target:PROTOCOL.ServiceFn('buy') as FnCallType,
-                arguments: [TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(i)), 
-                    txb.pure(BCS_CONVERT.ser_vector_u64(c)), TXB_OBJECT(txb, coin)],
+                arguments: [TXB_OBJECT(txb, service), txb.pure(BCS_CONVERT.ser_vector_string(name)), txb.pure(BCS_CONVERT.ser_vector_u64(price)), 
+                    txb.pure(BCS_CONVERT.ser_vector_u64(stock)), TXB_OBJECT(txb, coin)],
                 typeArguments:[pay_type]            
         })}           
     }

package/src/utils.ts

@@ -1,5 +1,5 @@
 import { SuiTransactionBlockResponse, SuiObjectChange } from '@mysten/sui.js/client';
-import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig } from '@mysten/bcs';
+import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, StructTypeDefinition } from '@mysten/bcs';
 import { PROTOCOL, MODULES, OBJECTS_TYPE } from './protocol';
 
 export const ulebDecode = (arr: number[] | Uint8Array) : {value: number, length: number} => {
@@ -97,6 +97,27 @@ export class Bcs {
     ser_vector_u64(data:number[]) : Uint8Array {
         return this.bcs.ser('vector<u64>', data).toBytes();
     }
+    ser_vector_u8(data:number[])  : Uint8Array {
+        return this.bcs.ser('vector<u8>', data).toBytes();
+    }
+    ser_address(data:string) : Uint8Array {
+        return this.bcs.ser(BCS.ADDRESS, data).toBytes();
+    }
+    ser_bool(data:boolean) : Uint8Array {
+        return this.bcs.ser(BCS.BOOL, data).toBytes();
+    }
+    ser_u8(data:number) : Uint8Array {
+        return this.bcs.ser(BCS.U8, data).toBytes();
+    }
+    ser_u64(data:number) : Uint8Array {
+        return this.bcs.ser(BCS.U64, data).toBytes();
+    }
+    ser_string(data:string) : Uint8Array {
+        return this.bcs.ser(BCS.STRING, data).toBytes();
+    }
+    de(type:TypeName | StructTypeDefinition, data:Uint8Array) {
+        return this.bcs.de(type, data)
+    }
 }
 
 export const BCS_CONVERT = new Bcs();
@@ -155,4 +176,29 @@ export function numToUint8Array(num:number) : Uint8Array {
         a.unshift(num & 255)
     }
     return new Uint8Array(a)
-} 
+} 
+
+// 判断是否为数组
+export const isArr = (origin: any): boolean => {
+    let str = '[object Array]'
+    return Object.prototype.toString.call(origin) == str ? true : false
+}
+
+
+export const deepClone = <T>(origin: T, target?: Record<string, any> | T ): T => {
+    let tar = target || {}
+
+    for (const key in origin) {
+        if (Object.prototype.hasOwnProperty.call(origin, key)) {
+            if (typeof origin[key] === 'object' && origin[key] !== null) {
+                tar[key] = isArr(origin[key]) ? [] : {}
+                deepClone(origin[key], tar[key])
+            } else {
+                tar[key] = origin[key]
+            }
+
+        }
+    }
+
+    return tar as T
+}