wowok 1.2.3 → 1.2.5

package/src/utils.ts

@@ -2,10 +2,10 @@ import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, StructTypeDefinit
 import { TransactionBlock, Inputs, TransactionResult, TransactionArgument } from '@mysten/sui.js/transactions';
 import { ERROR, Errors } from './exception';
 import { isValidSuiAddress, isValidSuiObjectId } from '@mysten/sui.js/utils'
-
+import { ValueType } from './protocol'
 
 export const OPTION_NONE = 0;
-export const readOption = (arr: number[], de:string) : {bNone:boolean, value:any}=> {
+export const readOption = (arr: number[], de:ValueType) : {bNone:boolean, value:any}=> {
     let o = arr.splice(0, 1);
     if (o[0] == 1) { // true
         return {bNone:false,  value:Bcs.getInstance().de(de, Uint8Array.from(arr))};
@@ -17,6 +17,21 @@ export const readOption = (arr: number[], de:string) : {bNone:boolean, value:any
     }
 }
 
+export const readOptionString = (arr: number[]) : {bNone:boolean, value:any}=> {
+    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: Uint8Array) : {value: number, length: number} => {
 	let total = 0;
 	let shift = 0;
@@ -125,63 +140,107 @@ export class Bcs {
         };
         return Bcs._instance;
      }
-    ser_option_string(data:string) : Uint8Array {
-        return this.bcs.ser('Option<string>', {'some': data}).toBytes();
-    }
-    ser_option_u64(data:number) : Uint8Array {
-        return this.bcs.ser('Option<u64>', {'some': data}).toBytes();
-    }
-    ser_option_address(data:string) : Uint8Array {
-        return this.bcs.ser('Option<address>', {'some': data}).toBytes();
-    }
-    ser_vector_string(data:string[]) : Uint8Array {
-        return this.bcs.ser('vector<string>', data).toBytes();
-    }
-    ser_vector_vector_u8(data:string[]) : Uint8Array {
-        return this.bcs.ser('vector<vector<u8>>', data).toBytes();
-    }
-    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_vector_address(data:number[])  : Uint8Array {
-        return this.bcs.ser('vector<address>', data).toBytes();
-    }
-    ser_vector_bool(data:number[])  : Uint8Array {
-        return this.bcs.ser('vector<bool>', data).toBytes();
-    }
-    ser_vector_u128(data:number[])  : Uint8Array {
-        return this.bcs.ser('vector<u128>', data).toBytes();
+    ser(type:ValueType, data:Uint8Array | any) : Uint8Array {
+        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();
     }
 
-    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_u128(data:number) : Uint8Array {
-        return this.bcs.ser(BCS.U128, data).toBytes();
-    }
-    ser_u256(data:number) : Uint8Array {
-        return this.bcs.ser(BCS.U256, data).toBytes();
-    }
-    ser_string(data:string) : Uint8Array {
-        return this.bcs.ser(BCS.STRING, data).toBytes();
-    }
-    ser(type:TypeName | StructTypeDefinition, data:Uint8Array) {
-        return this.bcs.ser(type, data).toBytes();
-    }
-    de(type:TypeName | StructTypeDefinition, data:Uint8Array) {
-        return this.bcs.de(type, data)
+    de(type:ValueType, data:Uint8Array | any) : any {
+        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');
+        }
     }
 }
 
@@ -239,11 +298,44 @@ export const IsValidDesription = (description:string) : boolean => { return desc
 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 IsValidAddress = (addr:string) : boolean => { if (!addr || !isValidSuiAddress(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 }
+export const IsValidAddress = (addr:string) : boolean => { 
+    if (!addr || !isValidSuiAddress(addr)) {
+        return false; 
+    }
+    return true
+}
+export const IsValidArgType = (argType: string) : boolean => { 
+    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: number | string) : boolean => { 
+    if (typeof(value) === 'string') {
+        value = parseInt(value as string);
+    }
+    return Number.isSafeInteger(value) && value > 0 
+}
+export const IsValidInt = (value: number | string) : boolean => { 
+    if (typeof(value) === 'string') {
+        value = parseInt(value as string);
+    }
+    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 IsValidArray = (arr: any[], validFunc:any) : boolean => {
     let bValid = true;
     arr.forEach((v) => {
@@ -262,13 +354,18 @@ export type ArgType = {
     token: string;
 }
 export const ParseType = (type:string) : ArgType => {
-    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/src/vote.ts

@@ -2,7 +2,7 @@ import { BCS } from '@mysten/bcs';
 import { FnCallType, PassportObject, PermissionObject, GuardObject, VoteAddress, Protocol, TxbObject} from './protocol';
 import { IsValidDesription, IsValidUint, IsValidAddress, OptionNone, Bcs, array_unique, IsValidArray, IsValidName } from './utils';
 import { ERROR, Errors } from './exception';
-import { Resource } from './resource';
+import { ValueType } from './protocol';
 
 export const MAX_AGREES_COUNT = 200;
 export const MAX_CHOICE_COUNT = 200;
@@ -51,7 +51,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) {
@@ -112,7 +112,7 @@ export class Vote {
         }
 
         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') as FnCallType,
@@ -207,7 +207,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) {
@@ -244,7 +244,7 @@ export class Vote {
                 txb.moveCall({
                     target:this.protocol.VoteFn('agrees_remove_with_passport') as FnCallType,
                     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)]
                 })             
             }
@@ -258,7 +258,7 @@ export class Vote {
                 txb.moveCall({
                     target:this.protocol.VoteFn('agrees_remove') as FnCallType,
                     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)]
                 })        
             }
@@ -360,13 +360,13 @@ export class Vote {
             txb.moveCall({
                 target:this.protocol.VoteFn('with_passport') as FnCallType,
                 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') as FnCallType,
                 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)))]
             })           
         }