wowok 1.2.3 → 1.2.5

package/dist/utils.js

@@ -1,6 +1,7 @@
 import { BCS, getSuiMoveConfig } from '@mysten/bcs';
 import { ERROR, Errors } from './exception';
 import { isValidSuiAddress } from '@mysten/sui.js/utils';
+import { ValueType } from './protocol';
 export const OPTION_NONE = 0;
 export const readOption = (arr, de) => {
     let o = arr.splice(0, 1);
@@ -15,6 +16,22 @@ export const readOption = (arr, de) => {
         return { bNone: true, value: OPTION_NONE };
     }
 };
+export const readOptionString = (arr) => {
+    let o = arr.splice(0, 1);
+    if (o[0] == 1) { // true
+        let r = ulebDecode(Uint8Array.from(arr));
+        let value = Bcs.getInstance().de(ValueType.TYPE_STRING, Uint8Array.from(arr));
+        arr.splice(0, r.value + r.length);
+        return { bNone: false, value: value };
+    }
+    else if (o[0] == 0) {
+        return { bNone: true, value: OPTION_NONE };
+    }
+    else {
+        ERROR(Errors.Fail, 'readOption: option invalid');
+        return { bNone: true, value: OPTION_NONE };
+    }
+};
 export const ulebDecode = (arr) => {
     let total = 0;
     let shift = 0;
@@ -113,62 +130,106 @@ export class Bcs {
         ;
         return Bcs._instance;
     }
-    ser_option_string(data) {
-        return this.bcs.ser('Option<string>', { 'some': data }).toBytes();
-    }
-    ser_option_u64(data) {
-        return this.bcs.ser('Option<u64>', { 'some': data }).toBytes();
-    }
-    ser_option_address(data) {
-        return this.bcs.ser('Option<address>', { 'some': data }).toBytes();
-    }
-    ser_vector_string(data) {
-        return this.bcs.ser('vector<string>', data).toBytes();
-    }
-    ser_vector_vector_u8(data) {
-        return this.bcs.ser('vector<vector<u8>>', data).toBytes();
-    }
-    ser_vector_u64(data) {
-        return this.bcs.ser('vector<u64>', data).toBytes();
-    }
-    ser_vector_u8(data) {
-        return this.bcs.ser('vector<u8>', data).toBytes();
-    }
-    ser_vector_address(data) {
-        return this.bcs.ser('vector<address>', data).toBytes();
-    }
-    ser_vector_bool(data) {
-        return this.bcs.ser('vector<bool>', data).toBytes();
-    }
-    ser_vector_u128(data) {
-        return this.bcs.ser('vector<u128>', data).toBytes();
-    }
-    ser_address(data) {
-        return this.bcs.ser(BCS.ADDRESS, data).toBytes();
-    }
-    ser_bool(data) {
-        return this.bcs.ser(BCS.BOOL, data).toBytes();
-    }
-    ser_u8(data) {
-        return this.bcs.ser(BCS.U8, data).toBytes();
-    }
-    ser_u64(data) {
-        return this.bcs.ser(BCS.U64, data).toBytes();
-    }
-    ser_u128(data) {
-        return this.bcs.ser(BCS.U128, data).toBytes();
-    }
-    ser_u256(data) {
-        return this.bcs.ser(BCS.U256, data).toBytes();
-    }
-    ser_string(data) {
-        return this.bcs.ser(BCS.STRING, data).toBytes();
-    }
     ser(type, data) {
-        return this.bcs.ser(type, data).toBytes();
+        switch (type) {
+            case ValueType.TYPE_BOOL:
+                return this.bcs.ser(BCS.BOOL, data).toBytes();
+            case ValueType.TYPE_ADDRESS:
+                return this.bcs.ser(BCS.ADDRESS, data).toBytes();
+            case ValueType.TYPE_U64:
+                return this.bcs.ser(BCS.U64, data).toBytes();
+            case ValueType.TYPE_U8:
+                return this.bcs.ser(BCS.U8, data).toBytes();
+            case ValueType.TYPE_VEC_U8:
+                return this.bcs.ser('vector<u8>', data).toBytes();
+            case ValueType.TYPE_U128:
+                return this.bcs.ser(BCS.U128, data).toBytes();
+            case ValueType.TYPE_VEC_ADDRESS:
+                return this.bcs.ser('vector<address>', data).toBytes();
+            case ValueType.TYPE_VEC_BOOL:
+                return this.bcs.ser('vector<bool>', data).toBytes();
+            case ValueType.TYPE_VEC_VEC_U8:
+                return this.bcs.ser('vector<vector<u8>>', data).toBytes();
+            case ValueType.TYPE_VEC_U64:
+                return this.bcs.ser('vector<u64>', data).toBytes();
+            case ValueType.TYPE_VEC_U128:
+                return this.bcs.ser('vector<u128>', data).toBytes();
+            case ValueType.TYPE_OPTION_ADDRESS:
+                return this.bcs.ser('Option<address>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_BOOL:
+                return this.bcs.ser('Option<bool>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_U8:
+                return this.bcs.ser('Option<u8>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_U64:
+                return this.bcs.ser('Option<u64>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_U128:
+                return this.bcs.ser('Option<u128>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_U256:
+                return this.bcs.ser('Option<u256>', { 'some': data }).toBytes();
+            case ValueType.TYPE_OPTION_STRING:
+                return this.bcs.ser('Option<string>', { 'some': data }).toBytes();
+            case ValueType.TYPE_VEC_U256:
+                return this.bcs.ser('vector<u256>', data).toBytes();
+            case ValueType.TYPE_U256:
+                return this.bcs.ser(BCS.U256, data).toBytes();
+            case ValueType.TYPE_STRING:
+                return this.bcs.ser(BCS.STRING, data).toBytes();
+            case ValueType.TYPE_VEC_STRING:
+                return this.bcs.ser('vector<string>', data).toBytes();
+            default:
+                ERROR(Errors.bcsTypeInvalid, 'ser');
+        }
+        return new Uint8Array();
     }
     de(type, data) {
-        return this.bcs.de(type, data);
+        switch (type) {
+            case ValueType.TYPE_BOOL:
+                return this.bcs.de(BCS.BOOL, data);
+            case ValueType.TYPE_ADDRESS:
+                return this.bcs.de(BCS.ADDRESS, data);
+            case ValueType.TYPE_U64:
+                return this.bcs.de(BCS.U64, data);
+            case ValueType.TYPE_U8:
+                return this.bcs.de(BCS.U8, data);
+            case ValueType.TYPE_VEC_U8:
+                return this.bcs.de('vector<u8>', data);
+            case ValueType.TYPE_U128:
+                return this.bcs.de(BCS.U128, data);
+            case ValueType.TYPE_VEC_ADDRESS:
+                return this.bcs.de('vector<address>', data);
+            case ValueType.TYPE_VEC_BOOL:
+                return this.bcs.de('vector<bool>', data);
+            case ValueType.TYPE_VEC_VEC_U8:
+                return this.bcs.de('vector<vector<u8>>', data);
+            case ValueType.TYPE_VEC_U64:
+                return this.bcs.de('vector<u64>', data);
+            case ValueType.TYPE_VEC_U128:
+                return this.bcs.de('vector<u128>', data);
+            case ValueType.TYPE_OPTION_ADDRESS:
+                return this.bcs.de('Option<address>', data);
+            case ValueType.TYPE_OPTION_BOOL:
+                return this.bcs.de('Option<bool>', data);
+            case ValueType.TYPE_OPTION_U8:
+                return this.bcs.de('Option<u8>', data);
+            case ValueType.TYPE_OPTION_U64:
+                return this.bcs.de('Option<u64>', data);
+            case ValueType.TYPE_OPTION_U128:
+                return this.bcs.de('Option<u128>', data);
+            case ValueType.TYPE_OPTION_U256:
+                return this.bcs.de('Option<u256>', data);
+            case ValueType.TYPE_OPTION_STRING:
+                return this.bcs.de('Option<string>', data);
+            case ValueType.TYPE_VEC_U256:
+                return this.bcs.de('vector<u256>', data);
+            case ValueType.TYPE_STRING:
+                return this.bcs.de(BCS.STRING, data);
+            case ValueType.TYPE_VEC_STRING:
+                return this.bcs.de('vector<string>', data);
+            case ValueType.TYPE_U256:
+                return this.bcs.de(BCS.U256, data);
+            default:
+                ERROR(Errors.bcsTypeInvalid, 'de');
+        }
     }
 }
 export function stringToUint8Array(str) {
@@ -220,13 +281,43 @@ export const IsValidName = (name) => { if (!name)
 export const IsValidName_AllowEmpty = (name) => { return name.length <= MAX_NAME_LENGTH; };
 export const IsValidEndpoint = (endpoint) => { if (!endpoint)
     return false; return endpoint.length <= MAX_ENDPOINT_LENGTH; };
-export const IsValidAddress = (addr) => { if (!addr || !isValidSuiAddress(addr))
-    return false; return true; };
-export const IsValidArgType = (argType) => { if (!argType)
-    return false; return argType.length != 0; };
-export const IsValidUint = (value) => { return Number.isSafeInteger(value) && value != 0; };
-export const IsValidInt = (value) => { return Number.isSafeInteger(value); };
-export const IsValidPercent = (value) => { return Number.isSafeInteger(value) && value > 0 && value <= 100; };
+export const IsValidAddress = (addr) => {
+    if (!addr || !isValidSuiAddress(addr)) {
+        return false;
+    }
+    return true;
+};
+export const IsValidArgType = (argType) => {
+    if (!argType || argType.length === 0) {
+        return false;
+    }
+    let arr = argType.split('::');
+    if (arr.length !== 3) {
+        return false;
+    }
+    if (!IsValidAddress(arr[0]) || arr[1].length === 0 || arr[2].length === 0) {
+        return false;
+    }
+    return true;
+};
+export const IsValidUint = (value) => {
+    if (typeof (value) === 'string') {
+        value = parseInt(value);
+    }
+    return Number.isSafeInteger(value) && value > 0;
+};
+export const IsValidInt = (value) => {
+    if (typeof (value) === 'string') {
+        value = parseInt(value);
+    }
+    return Number.isSafeInteger(value);
+};
+export const IsValidPercent = (value) => {
+    if (typeof (value) === 'string') {
+        value = parseInt(value);
+    }
+    return Number.isSafeInteger(value) && value > 0 && value <= 100;
+};
 export const IsValidArray = (arr, validFunc) => {
     let bValid = true;
     arr.forEach((v) => {
@@ -238,13 +329,19 @@ export const IsValidArray = (arr, validFunc) => {
 };
 export const OptionNone = (txb) => { return txb.pure([], BCS.U8); };
 export const ParseType = (type) => {
-    let i = type.indexOf('<');
-    if (i > 0 && type.length > 12) {
-        let c = type.slice(0, i);
-        if (c === '0x2::coin::Coin' || c === '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin') {
-            let coin = type.slice(i + 1, type.length - 1); // < >>
-            let t = coin.lastIndexOf('::');
-            return { isCoin: true, coin: coin, token: coin.slice(t + 2) };
+    if (type) {
+        const COIN = '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<';
+        let i = type.indexOf(COIN);
+        if (i > 0) {
+            let coin = type.slice(i + COIN.length, type.length - 1);
+            if (coin.indexOf('<') === -1) {
+                while (coin[coin.length - 1] == '>') {
+                    coin = coin.slice(0, -1);
+                }
+                ;
+                let t = coin.lastIndexOf('::');
+                return { isCoin: true, coin: coin, token: coin.slice(t + 2) };
+            }
         }
     }
     return { isCoin: false, coin: '', token: '' };

package/dist/vote.js

@@ -2,6 +2,7 @@ import { BCS } from '@mysten/bcs';
 import { Protocol } from './protocol';
 import { IsValidDesription, IsValidUint, IsValidAddress, OptionNone, Bcs, array_unique, IsValidArray, IsValidName } from './utils';
 import { ERROR, Errors } from './exception';
+import { ValueType } from './protocol';
 export const MAX_AGREES_COUNT = 200;
 export const MAX_CHOICE_COUNT = 200;
 export class Vote {
@@ -40,7 +41,7 @@ export class Vote {
         }
         let v = new Vote(protocol, permission);
         let txb = protocol.CurrentSession();
-        let reference = reference_address ? txb.pure(Bcs.getInstance().ser_option_address(reference_address)) : OptionNone(txb);
+        let reference = reference_address ? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_ADDRESS, reference_address)) : OptionNone(txb);
         let choice_count = max_choice_count ? max_choice_count : 1;
         if (passport) {
             v.object = txb.moveCall({
@@ -95,7 +96,7 @@ export class Vote {
             ERROR(Errors.IsValidAddress);
         }
         let txb = this.protocol.CurrentSession();
-        let reference = reference_address ? txb.pure(Bcs.getInstance().ser_option_address(reference_address)) : OptionNone(txb);
+        let reference = reference_address ? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_ADDRESS, reference_address)) : OptionNone(txb);
         if (passport) {
             txb.moveCall({
                 target: this.protocol.VoteFn('reference_set_with_passport'),
@@ -189,7 +190,7 @@ export class Vote {
         let txb = this.protocol.CurrentSession();
         options.forEach((option) => {
             let reference = option?.reference_address ?
-                txb.pure(Bcs.getInstance().ser_option_address(option.reference_address)) :
+                txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_ADDRESS, option.reference_address)) :
                 OptionNone(txb);
             if (passport) {
                 txb.moveCall({
@@ -226,7 +227,7 @@ export class Vote {
                 txb.moveCall({
                     target: this.protocol.VoteFn('agrees_remove_with_passport'),
                     arguments: [passport, Protocol.TXB_OBJECT(txb, this.object),
-                        txb.pure(Bcs.getInstance().ser_vector_string(array_unique(options))),
+                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options))),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 });
             }
@@ -242,7 +243,7 @@ export class Vote {
                 txb.moveCall({
                     target: this.protocol.VoteFn('agrees_remove'),
                     arguments: [Protocol.TXB_OBJECT(txb, this.object),
-                        txb.pure(Bcs.getInstance().ser_vector_string(array_unique(options))),
+                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options))),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 });
             }
@@ -341,14 +342,14 @@ export class Vote {
             txb.moveCall({
                 target: this.protocol.VoteFn('with_passport'),
                 arguments: [passport, Protocol.TXB_OBJECT(txb, this.object),
-                    txb.pure(Bcs.getInstance().ser_vector_string(array_unique(options)))]
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options)))]
             });
         }
         else {
             txb.moveCall({
                 target: this.protocol.VoteFn('this.object'),
                 arguments: [Protocol.TXB_OBJECT(txb, this.object),
-                    txb.pure(Bcs.getInstance().ser_vector_string(array_unique(options)))]
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(options)))]
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "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/exception.ts

@@ -18,6 +18,7 @@ export enum Errors {
     Fail = 'fail',
     IsValidIndentifier = 'indentifier invalid',
     isValidHttpUrl = 'invalid url',
+    bcsTypeInvalid = 'invalid bcs type',
 }
 
 export const ERROR = (error:Errors, info?:any) =>  {

package/src/guard.ts

@@ -269,7 +269,8 @@ export class GuardConstantHelper {
         let v = constants.get(identifier);
         if (!v || v.type == ContextType.TYPE_WITNESS_ID) {
             if (bNeedSerialize) {
-                constants.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value ? Bcs.getInstance().ser_address(value) : undefined, witness:witness ? Bcs.getInstance().ser_address(witness) : undefined})
+                constants.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value ? Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, value) : undefined, 
+                    witness:witness ? Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, witness) : undefined})
             } else {
                 constants.set(identifier, {type:ContextType.TYPE_WITNESS_ID, value:value?value:undefined, witness:witness?witness:undefined});             
             }                     
@@ -301,12 +302,12 @@ export class GuardConstantHelper {
             case ValueType.TYPE_VEC_U256:
                 let ser = SER_VALUE.find(s=>s.type==type);
                 if (!ser) ERROR(Errors.Fail, 'add_constant: invalid type');
-                bNeedSerialize ? constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.name, value)}) :
+                bNeedSerialize ? constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ser!.type, value)}) :
                 constants.set(identifier,  {type:type, value:value})    
                 return         
             case ValueType.TYPE_VEC_U8:
                 if (typeof(value) === 'string') {
-                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser_string(value)})                 
+                    constants.set(identifier, {type:type, value:Bcs.getInstance().ser(ValueType.TYPE_STRING, value)})                 
                 } else {
                     constants.set(identifier,  {type:type, value:value})      
                 }
@@ -344,10 +345,10 @@ export class GuardMaker {
 
     private  serValueParam(type:ValueType, param?:any) {
         if (!param) ERROR(Errors.InvalidParam, 'param');
-        this.data.push(Bcs.getInstance().ser_u8(type));
+        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
         let ser = SER_VALUE.find(s=>s.type==type);
         if (!ser) ERROR(Errors.Fail, 'serValueParam: invalid type');
-        this.data.push(Bcs.getInstance().ser(ser!.name, param));
+        this.data.push(Bcs.getInstance().ser(ser!.type, param));
         this.type_validator.push(type);
     }
 
@@ -376,26 +377,26 @@ export class GuardMaker {
             break;
         case ValueType.TYPE_VEC_U8:
             if (!param) ERROR(Errors.InvalidParam, 'param');
-            this.data.push(Bcs.getInstance().ser_u8(type));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
             if (typeof(param) == 'string') {
-                this.data.push(Bcs.getInstance().ser_string(param));
+                this.data.push(Bcs.getInstance().ser(ValueType.TYPE_STRING, param));
             } else {
-                this.data.push(Bcs.getInstance().ser_vector_u8(param));
+                this.data.push(Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, param));
             }
             this.type_validator.push(type);
             break;
         case ContextType.TYPE_SIGNER:
-            this.data.push(Bcs.getInstance().ser_u8(type));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
             this.type_validator.push(ValueType.TYPE_ADDRESS);
             break;
         case ContextType.TYPE_CLOCK:
-            this.data.push(Bcs.getInstance().ser_u8(type));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
             this.type_validator.push(ValueType.TYPE_U64);
             break;
         case ContextType.TYPE_WITNESS_ID:
             if (!param) ERROR(Errors.InvalidParam, 'param');
-            this.data.push(Bcs.getInstance().ser_u8(type));
-            this.data.push(Bcs.getInstance().ser_address(param));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, param));
             this.type_validator.push(ValueType.TYPE_ADDRESS);
             break;   
         case ContextType.TYPE_CONSTANT:
@@ -409,8 +410,8 @@ export class GuardMaker {
             var v = this.constant.get(param);
             if (!v) ERROR(Errors.Fail, 'identifier not in constant');
             this.type_validator.push(v!.type);
-            this.data.push(Bcs.getInstance().ser_u8(type));
-            this.data.push(Bcs.getInstance().ser_u8(param));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type));
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, param));
             break;
         default:
             ERROR(Errors.InvalidParam, 'add_param type');
@@ -445,23 +446,23 @@ export class GuardMaker {
             ERROR(Errors.Fail, 'array_equal');
         }
         
-        this.data.push(Bcs.getInstance().ser_u8(OperatorType.TYPE_QUERY)); // QUERY TYPE
+        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_QUERY)); // QUERY TYPE
         if (typeof(object_address_from) == 'string') {
-            bWitness ? this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_WITNESS_ID)) :
-                this.data.push(Bcs.getInstance().ser_u8(ValueType.TYPE_ADDRESS)); 
-            this.data.push(Bcs.getInstance().ser_address(object_address_from)); // object address            
+            bWitness ? this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_WITNESS_ID)) :
+                this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ValueType.TYPE_ADDRESS)); 
+            this.data.push(Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, object_address_from)); // object address            
         } else {
             let v =  this.constant.get(object_address_from);
             if (!v) ERROR(Errors.Fail, 'object_address_from not in constant');
             if ((bWitness && v?.type == ContextType.TYPE_WITNESS_ID) || (!bWitness && v?.type == ValueType.TYPE_ADDRESS)) {
-                this.data.push(Bcs.getInstance().ser_u8(ContextType.TYPE_CONSTANT));
-                this.data.push(Bcs.getInstance().ser_u8(object_address_from)); // object identifer in constants
+                this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, ContextType.TYPE_CONSTANT));
+                this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, object_address_from)); // object identifer in constants
             } else {
                 ERROR(Errors.Fail, 'type bWitness not match')
             }
         }
 
-        this.data.push(Bcs.getInstance().ser_u8(Guard.QUERIES[query_index][2])); // cmd
+        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, Guard.QUERIES[query_index][2])); // cmd
         this.type_validator.splice(offset, Guard.QUERIES[query_index][3].length); // delete type stack
         this.type_validator.push(Guard.QUERIES[query_index][4]); // add the return value type to type stack
         return this;
@@ -499,7 +500,7 @@ export class GuardMaker {
             default:
                 ERROR(Errors.InvalidParam, 'type') 
         }
-        this.data.push(Bcs.getInstance().ser_u8(type)); // TYPE     
+        this.data.push(Bcs.getInstance().ser(ValueType.TYPE_U8, type)); // TYPE     
         this.type_validator.splice(this.type_validator.length - splice_len); // delete type stack   
         this.type_validator.push(ValueType.TYPE_BOOL); // add bool to type stack
         return this;
@@ -536,7 +537,7 @@ export class GuardMaker {
             maker.constant.set(k, {type:v.type, value:v.value, witness:v.witness});
         })
         let op = bAnd ? OperatorType.TYPE_LOGIC_AND :  OperatorType.TYPE_LOGIC_OR;
-        maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser_u8(op)));
+        maker.data.push(concatenate(Uint8Array, ...this.data, ...otherBuilt.data, Bcs.getInstance().ser(ValueType.TYPE_U8, op)));
         this.data.splice(0, this.data.length-1);
         maker.type_validator = this.type_validator;
         return maker
@@ -547,10 +548,10 @@ export class GuardMaker {
 
     static input_combine(input1:Uint8Array, input2:Uint8Array, bAnd:boolean = true) : Uint8Array {
         let op = bAnd ? OperatorType.TYPE_LOGIC_AND :  OperatorType.TYPE_LOGIC_OR;
-        return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser_u8(op)) as  Uint8Array;
+        return concatenate(Uint8Array, input1, input2, Bcs.getInstance().ser(ValueType.TYPE_U8, op)) as  Uint8Array;
     }
     static input_not(input:Uint8Array) : Uint8Array {
-        return concatenate(Uint8Array, input, Bcs.getInstance().ser_u8(OperatorType.TYPE_LOGIC_NOT)) as Uint8Array;
+        return concatenate(Uint8Array, input, Bcs.getInstance().ser(ValueType.TYPE_U8, OperatorType.TYPE_LOGIC_NOT)) as Uint8Array;
     }
 
     static match_u256(type:number) : boolean {

package/src/machine.ts

@@ -5,7 +5,7 @@ import { IsValidInt, IsValidUint, Bcs, array_unique, IsValidArray, IsValidAddres
     IsValidEndpoint, OptionNone, IsValidDesription} from './utils'
 import { Permission, PermissionIndexType } from './permission';
 import { Errors, ERROR}  from './exception'
-import { Resource } from './resource';
+import { ValueType } from './protocol';
 
 
 export type MachineNodeObject = TransactionResult | String;
@@ -59,7 +59,7 @@ export class Machine {
 
         let m = new Machine(protocol, permission);
         let txb = protocol.CurrentSession();
-        let ep = endpoint? txb.pure(Bcs.getInstance().ser_option_string(endpoint)) : OptionNone(txb);
+        let ep = endpoint? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_STRING, endpoint)) : OptionNone(txb);
     
         if (passport) {
             m.object = txb.moveCall({
@@ -104,11 +104,11 @@ export class Machine {
                 arguments:[txb.pure(node.name), txb.pure(node.description)]
             });
             node.pairs.forEach((pair) => {
-                let threshold = pair?.threshold ? txb.pure(Bcs.getInstance().ser_option_u64(pair.threshold)) : OptionNone(txb);
+                let threshold = pair?.threshold ? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_U64, pair.threshold)) : OptionNone(txb);
 
                 pair.forwards.forEach((forward) => {
                     let weight = forward?.weight ? forward.weight : 1;
-                    let perm = forward?.permission ? txb.pure(Bcs.getInstance().ser_option_u64(forward.permission)) : OptionNone(txb); 
+                    let perm = forward?.permission ? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_U64, forward.permission)) : OptionNone(txb); 
                     let namedOperator = forward?.namedOperator ?  txb.pure(forward.namedOperator) : txb.pure('');
                     let f;
 
@@ -169,13 +169,13 @@ export class Machine {
         if (passport) {
             txb.moveCall({
                 target:this.protocol.MachineFn('node_remove_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(txb,  this.object), txb.pure(Bcs.getInstance().ser_vector_string(nodes_name)), 
+                arguments:[passport, Protocol.TXB_OBJECT(txb,  this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), 
                     txb.pure(bTransferMyself, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
             });  
         } else {
             txb.moveCall({
                 target:this.protocol.MachineFn('node_remove') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb,  this.object), txb.pure(Bcs.getInstance().ser_vector_string(nodes_name)), txb.pure(bTransferMyself, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
+                arguments:[Protocol.TXB_OBJECT(txb,  this.object), txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, nodes_name)), txb.pure(bTransferMyself, BCS.BOOL), Protocol.TXB_OBJECT(txb, this.permission)],
             });
         } 
     }
@@ -288,7 +288,7 @@ export class Machine {
         }
 
         let txb = this.protocol.CurrentSession();
-        let ep = endpoint? txb.pure(Bcs.getInstance().ser_option_string(endpoint)) : OptionNone(txb);
+        let ep = endpoint? txb.pure(Bcs.getInstance().ser(ValueType.TYPE_OPTION_STRING, endpoint)) : OptionNone(txb);
         
         if (passport) {
             txb.moveCall({