wowok 1.2.5 → 1.2.7

package/src/utils.ts

@@ -1,10 +1,64 @@
-import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, StructTypeDefinition } from '@mysten/bcs';
+import { bcs, BCS, toHEX, fromHEX, getSuiMoveConfig, TypeName, BcsReader } from '@mysten/bcs';
 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'
+import { RepositoryValueType, ValueType } from './protocol'
+
+export const MAX_U8 = BigInt('256');
+export const MAX_U64 = BigInt('18446744073709551615');
+export const MAX_U128 = BigInt('340282366920938463463374607431768211455');
+export const MAX_U256 = BigInt('115792089237316195423570985008687907853269984665640564039457584007913129639935');
 
 export const OPTION_NONE = 0;
+
+export const ValueTypeConvert = (type:ValueType | null | undefined) : RepositoryValueType | number => {
+    if (type === ValueType.TYPE_U8 || type === ValueType.TYPE_U64 || type === ValueType.TYPE_U128 || 
+        type === ValueType.TYPE_U256 || type === ValueType.TYPE_BOOL) {
+            return RepositoryValueType.PositiveNumber
+    } else if (type === ValueType.TYPE_VEC_U8 || type === ValueType.TYPE_VEC_U64 || type === ValueType.TYPE_VEC_U128 || 
+        type === ValueType.TYPE_VEC_U256|| type === ValueType.TYPE_VEC_BOOL) {
+            return RepositoryValueType.PositiveNumber_Vec
+    } else if (type === ValueType.TYPE_ADDRESS) {
+        return RepositoryValueType.Address
+    } else if (type === ValueType.TYPE_VEC_ADDRESS) {
+        return RepositoryValueType.Address_Vec
+    } else if (type === ValueType.TYPE_STRING) {
+        return RepositoryValueType.String
+    } else if (type === ValueType.TYPE_VEC_STRING) {
+        return RepositoryValueType.String_Vec
+    } 
+    return -1;
+}
+
+export const ResolveRepositoryData = (dataType:RepositoryValueType, data:Uint8Array) : {type:ValueType, data: Uint8Array} | undefined =>  {
+    if (dataType === RepositoryValueType.String) { 
+        return {type: ValueType.TYPE_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_U8, new TextEncoder().encode(data.toString()))}
+   } else if (dataType === RepositoryValueType.PositiveNumber) {
+        try {
+            const value = BigInt(data.toString());
+            var t = ValueType.TYPE_U8;
+            if (value <= MAX_U8) {
+            } else if (value <= MAX_U64) {
+                t = ValueType.TYPE_U64;
+            } else if (value <= MAX_U128) {
+                t = ValueType.TYPE_U128;
+            } else if (value <= MAX_U256) {
+                t = ValueType.TYPE_U256;
+            } else {
+                return undefined
+            }
+        } catch (e) {
+            console.log(e)
+            return undefined
+        }
+        return {type:t, data:Bcs.getInstance().ser(t, data)}
+   } else if (dataType === RepositoryValueType.Address) {
+        return {type:ValueType.TYPE_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, data)}
+   } 
+   //@ todo vector....
+   return undefined
+}
+
 export const readOption = (arr: number[], de:ValueType) : {bNone:boolean, value:any}=> {
     let o = arr.splice(0, 1);
     if (o[0] == 1) { // true
@@ -133,6 +187,20 @@ export class Bcs {
             'none': null,
             'some': 'T',
         });
+        this.bcs.registerStructType('EntStruct', {
+            'avatar': 'vector<u8>',
+            'resource': "Option<address>",
+            'like': BCS.U32,
+            'dislike': BCS.U32,
+        })
+        this.bcs.registerStructType('PersonalInfo', {
+            'name': 'vector<u8>',
+            'description': 'vector<u8>',
+            'avatar': BCS.STRING,
+            'twitter': BCS.STRING,
+            'discord': BCS.STRING,
+            'homepage': BCS.STRING,
+        })
     }
     static getInstance() : Bcs { 
         if (!Bcs._instance) {
@@ -140,6 +208,7 @@ export class Bcs {
         };
         return Bcs._instance;
      }
+
     ser(type:ValueType, data:Uint8Array | any) : Uint8Array {
         switch(type) {
             case ValueType.TYPE_BOOL:
@@ -201,6 +270,7 @@ 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);
@@ -242,6 +312,30 @@ export class Bcs {
                 ERROR(Errors.bcsTypeInvalid, 'de');
         }
     }
+
+    de_ent(data:Uint8Array) : any {
+        const struct_vec = this.bcs.de('vector<u8>', data);
+        return this.bcs.de('EntStruct', Uint8Array.from(struct_vec));
+/*        const reader = new BcsReader(data);
+        const total_len = reader.readULEB();
+        console.log(avatar_len)
+        const avatar = reader.readBytes(avatar_len);
+        console.log(avatar)
+        const option_resource = reader.read8();
+        var resource = '';
+        if (option_resource != 0) {
+            resource = reader.read256();
+        }
+        const like = reader.read32();
+        const dislike = reader.read32();
+        return {avatar:avatar, resource:resource, like:like, dislike:dislike}*/
+    }    
+    de_entInfo(data:Uint8Array) : any {
+        let r = this.bcs.de('PersonalInfo', data);
+        r.name = new TextDecoder().decode(Uint8Array.from(r.name));
+        r.description = new TextDecoder().decode(Uint8Array.from(r.description));
+        return r
+    }        
 }
 
 export function stringToUint8Array(str:string) : Uint8Array {
@@ -264,7 +358,6 @@ export function numToUint8Array(num:number) : Uint8Array {
     return new Uint8Array(a)
 } 
 
-// 判断是否为数组
 export const isArr = (origin: any): boolean => {
     let str = '[object Array]'
     return Object.prototype.toString.call(origin) == str ? true : false
@@ -304,7 +397,7 @@ export const IsValidAddress = (addr:string) : boolean => {
     }
     return true
 }
-export const IsValidArgType = (argType: string) : boolean => { 
+export const IsValidTokenType = (argType: string) : boolean => { 
     if (!argType || argType.length === 0) {
         return false; 
     }
@@ -312,12 +405,21 @@ export const IsValidArgType = (argType: string) : boolean => {
     if (arr.length !== 3) {
         return false;
     } 
-    if (!IsValidAddress(arr[0]) || arr[1].length === 0 || arr[2].length === 0) {
+    if ((!IsValidAddress(arr[0]) && arr[0] != '0x2') || arr[1].length === 0 || arr[2].length === 0) {
         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;
+    } 
+    return true;
+}
 export const IsValidUint = (value: number | string) : boolean => { 
     if (typeof(value) === 'string') {
         value = parseInt(value as string);
@@ -337,13 +439,37 @@ export const IsValidPercent = (value: number | string) : boolean => {
     return Number.isSafeInteger(value) && value > 0 && value <= 100 
 }
 export const IsValidArray = (arr: any[], validFunc:any) : boolean => {
-    let bValid = true;
-    arr.forEach((v) => {
-        if (!validFunc(v)) {
-            bValid = false; 
+    for (let i = 0; i < arr.length; ++i) {
+        if (!validFunc(arr[i])) {
+            return false
         }
-    })
-    return bValid;
+    }
+    return true
+}
+
+export const ResolveU64 = (value:bigint) : bigint => {
+    const max = MAX_U64;
+    if (value > max) {
+        return max;
+    } else {
+        return value
+    }
+}
+
+export const ResolveBalance = (balance:string, decimals:number) : string => {
+    if (!balance) return ''
+    if (balance === '0') return '0'
+    if (decimals <= 0) return balance;
+    var pos = decimals - balance.length;
+    if (pos === 0) {
+       return '.' + balance;
+    } else if (pos < 0) {
+        let start = balance.slice(0, Math.abs(pos));
+        let end = balance.slice(Math.abs(pos));
+        return start + '.' + end;
+    } else {
+        return '.' + balance.padStart(pos, '0');
+    }
 }
 
 export const OptionNone = (txb:TransactionBlock) : TransactionArgument => { return txb.pure([], BCS.U8) };
@@ -355,9 +481,9 @@ export type ArgType = {
 }
 export const ParseType = (type:string) : ArgType => {
     if (type) {
-        const COIN = '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<';
+        const COIN = '0x2::coin::Coin<';
         let i = type.indexOf(COIN);
-        if (i > 0) {
+        if (i >= 0) {
             let coin = type.slice(i+COIN.length, type.length-1);
             if (coin.indexOf('<') === -1) {
                 while (coin[coin.length-1] == '>') {
@@ -398,5 +524,5 @@ export function isValidHttpUrl(url:string) : boolean {
       return false;  
     }
   
-    return r.protocol === "http:" || r.protocol === "https:";
+    return r.protocol === "http:" || r.protocol === "https:" || r.protocol === 'ipfs:';
 }

package/src/vote.ts

@@ -28,7 +28,7 @@ export class Vote {
         v.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object)
         return v
     }
-    static New(protocol:Protocol, permission:PermissionObject, description:string, minutes_duration:number, 
+    static New(protocol:Protocol, permission:PermissionObject, description:string, minutes_duration:boolean,  time:number,
         max_choice_count?:number, reference_address?:string, passport?:PassportObject) : Vote {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects,  'permission')
@@ -36,8 +36,8 @@ export class Vote {
         if (!IsValidDesription(description)) {
             ERROR(Errors.IsValidDesription)
         }
-        if (!IsValidUint(minutes_duration)) {
-            ERROR(Errors.IsValidUint, 'minutes_duration')
+        if (!IsValidUint(time)) {
+            ERROR(Errors.IsValidUint, 'time')
         }
         if (max_choice_count && !IsValidUint(max_choice_count)) {
             ERROR(Errors.IsValidUint, 'max_choice_count')
@@ -57,14 +57,14 @@ export class Vote {
         if (passport) {
             v.object = txb.moveCall({
                 target:protocol.VoteFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure(description), reference, txb.pure(Protocol.CLOCK_OBJECT), 
-                    txb.pure(minutes_duration, BCS.U64), txb.pure(choice_count, BCS.U8), Protocol.TXB_OBJECT(txb, permission)]
+                arguments:[passport, txb.pure(description), reference, txb.pure(Protocol.CLOCK_OBJECT), txb.pure(minutes_duration, BCS.BOOL),
+                    txb.pure(time, BCS.U64), txb.pure(choice_count, BCS.U8), Protocol.TXB_OBJECT(txb, permission)]
             })
         } else {
             v.object = txb.moveCall({
                 target:protocol.VoteFn('new') as FnCallType,
-                arguments:[txb.pure(description), reference, txb.pure(Protocol.CLOCK_OBJECT), 
-                    txb.pure(minutes_duration, BCS.U64), txb.pure(choice_count, BCS.U8), Protocol.TXB_OBJECT(txb, permission)]
+                arguments:[txb.pure(description), reference, txb.pure(Protocol.CLOCK_OBJECT), txb.pure(minutes_duration, BCS.BOOL),
+                    txb.pure(time, BCS.U64), txb.pure(choice_count, BCS.U8), Protocol.TXB_OBJECT(txb, permission)]
             })
         }
         return v
@@ -314,23 +314,23 @@ export class Vote {
         }
     }
 
-    expand_deadline(minutes_expand:number, passport?:PassportObject)  {
-        if (!IsValidUint(minutes_expand)) {
-            ERROR(Errors.IsValidUint, 'minutes_expand')
+    expand_deadline(ms_expand:boolean, time:number, passport?:PassportObject)  {
+        if (!IsValidUint(time)) {
+            ERROR(Errors.IsValidUint, 'time')
         }
 
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
                 target:this.protocol.VoteFn('deadline_expand_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
-                    txb.pure(minutes_expand, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)]
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(ms_expand, BCS.BOOL),
+                    txb.pure(time, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)]
             })  
         } else {
             txb.moveCall({
                 target:this.protocol.VoteFn('deadline_expand') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), 
-                    txb.pure(minutes_expand, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)]
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(ms_expand, BCS.BOOL),
+                    txb.pure(time, BCS.U64), Protocol.TXB_OBJECT(txb, this.permission)]
             })  
         }