wowok 1.2.4 → 1.2.7

package/dist/utils.js

@@ -1,8 +1,70 @@
 import { BCS, getSuiMoveConfig } from '@mysten/bcs';
 import { ERROR, Errors } from './exception';
 import { isValidSuiAddress } 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) => {
+    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, data) => {
+    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, de) => {
     let o = arr.splice(0, 1);
     if (o[0] == 1) { // true
@@ -122,6 +184,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() {
         if (!Bcs._instance) {
@@ -184,53 +260,77 @@ export class Bcs {
     de(type, data) {
         switch (type) {
             case ValueType.TYPE_BOOL:
-                return this.bcs.de(BCS.BOOL, data).toBytes();
+                return this.bcs.de(BCS.BOOL, data);
             case ValueType.TYPE_ADDRESS:
-                return this.bcs.de(BCS.ADDRESS, data).toBytes();
+                return this.bcs.de(BCS.ADDRESS, data);
             case ValueType.TYPE_U64:
-                return this.bcs.de(BCS.U64, data).toBytes();
+                return this.bcs.de(BCS.U64, data);
             case ValueType.TYPE_U8:
-                return this.bcs.de(BCS.U8, data).toBytes();
+                console.log(data);
+                return this.bcs.de(BCS.U8, data);
             case ValueType.TYPE_VEC_U8:
-                return this.bcs.de('vector<u8>', data).toBytes();
+                return this.bcs.de('vector<u8>', data);
             case ValueType.TYPE_U128:
-                return this.bcs.de(BCS.U128, data).toBytes();
+                return this.bcs.de(BCS.U128, data);
             case ValueType.TYPE_VEC_ADDRESS:
-                return this.bcs.de('vector<address>', data).toBytes();
+                return this.bcs.de('vector<address>', data);
             case ValueType.TYPE_VEC_BOOL:
-                return this.bcs.de('vector<bool>', data).toBytes();
+                return this.bcs.de('vector<bool>', data);
             case ValueType.TYPE_VEC_VEC_U8:
-                return this.bcs.de('vector<vector<u8>>', data).toBytes();
+                return this.bcs.de('vector<vector<u8>>', data);
             case ValueType.TYPE_VEC_U64:
-                return this.bcs.de('vector<u64>', data).toBytes();
+                return this.bcs.de('vector<u64>', data);
             case ValueType.TYPE_VEC_U128:
-                return this.bcs.de('vector<u128>', data).toBytes();
+                return this.bcs.de('vector<u128>', data);
             case ValueType.TYPE_OPTION_ADDRESS:
-                return this.bcs.de('Option<address>', data).toBytes();
+                return this.bcs.de('Option<address>', data);
             case ValueType.TYPE_OPTION_BOOL:
-                return this.bcs.de('Option<bool>', data).toBytes();
+                return this.bcs.de('Option<bool>', data);
             case ValueType.TYPE_OPTION_U8:
-                return this.bcs.de('Option<u8>', data).toBytes();
+                return this.bcs.de('Option<u8>', data);
             case ValueType.TYPE_OPTION_U64:
-                return this.bcs.de('Option<u64>', data).toBytes();
+                return this.bcs.de('Option<u64>', data);
             case ValueType.TYPE_OPTION_U128:
-                return this.bcs.de('Option<u128>', data).toBytes();
+                return this.bcs.de('Option<u128>', data);
             case ValueType.TYPE_OPTION_U256:
-                return this.bcs.de('Option<u256>', data).toBytes();
+                return this.bcs.de('Option<u256>', data);
             case ValueType.TYPE_OPTION_STRING:
-                return this.bcs.de('Option<string>', data).toBytes();
+                return this.bcs.de('Option<string>', data);
             case ValueType.TYPE_VEC_U256:
-                return this.bcs.de('vector<u256>', data).toBytes();
+                return this.bcs.de('vector<u256>', data);
             case ValueType.TYPE_STRING:
-                return this.bcs.de(BCS.STRING, data).toBytes();
+                return this.bcs.de(BCS.STRING, data);
             case ValueType.TYPE_VEC_STRING:
-                return this.bcs.de('vector<string>', data).toBytes();
+                return this.bcs.de('vector<string>', data);
             case ValueType.TYPE_U256:
-                return this.bcs.de(BCS.U256, data).toBytes();
+                return this.bcs.de(BCS.U256, data);
             default:
                 ERROR(Errors.bcsTypeInvalid, 'de');
         }
     }
+    de_ent(data) {
+        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) {
+        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) {
     var arr = [];
@@ -251,7 +351,6 @@ export function numToUint8Array(num) {
     }
     return new Uint8Array(a);
 }
-// 判断是否为数组
 export const isArr = (origin) => {
     let str = '[object Array]';
     return Object.prototype.toString.call(origin) == str ? true : false;
@@ -281,31 +380,105 @@ 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 IsValidTokenType = (argType) => {
+    if (!argType || argType.length === 0) {
+        return false;
+    }
+    let arr = argType.split('::');
+    if (arr.length !== 3) {
+        return false;
+    }
+    if ((!IsValidAddress(arr[0]) && arr[0] != '0x2') || arr[1].length === 0 || arr[2].length === 0) {
+        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;
+    }
+    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) => {
-        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) => {
+    const max = MAX_U64;
+    if (value > max) {
+        return max;
+    }
+    else {
+        return value;
+    }
+};
+export const ResolveBalance = (balance, decimals) => {
+    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) => { 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 = '0x2::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: '' };
@@ -337,5 +510,5 @@ export function isValidHttpUrl(url) {
     catch (_) {
         return false;
     }
-    return r.protocol === "http:" || r.protocol === "https:";
+    return r.protocol === "http:" || r.protocol === "https:" || r.protocol === 'ipfs:';
 }

package/dist/vote.d.ts

@@ -12,7 +12,7 @@ export declare class Vote {
     get_object(): TxbObject;
     private constructor();
     static From(protocol: Protocol, permission: PermissionObject, object: TxbObject): Vote;
-    static New(protocol: Protocol, permission: PermissionObject, description: string, minutes_duration: number, max_choice_count?: number, reference_address?: string, passport?: PassportObject): Vote;
+    static New(protocol: Protocol, permission: PermissionObject, description: string, minutes_duration: boolean, time: number, max_choice_count?: number, reference_address?: string, passport?: PassportObject): Vote;
     launch(): VoteAddress;
     destroy(): void;
     set_description(description: string, passport?: PassportObject): void;
@@ -24,7 +24,7 @@ export declare class Vote {
     set_max_choice_count(max_choice_count: number, passport?: PassportObject): void;
     open_voting(passport?: PassportObject): void;
     lock_deadline(passport?: PassportObject): void;
-    expand_deadline(minutes_expand: number, passport?: PassportObject): void;
+    expand_deadline(ms_expand: boolean, time: number, passport?: PassportObject): void;
     lock_guard(passport?: PassportObject): void;
     agree(options: string[], passport?: PassportObject): void;
     change_permission(new_permission: PermissionObject): void;

package/dist/vote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vote.d.ts","sourceRoot":"","sources":["../src/vote.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAC,MAAM,YAAY,CAAC;AAKxH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG;IACrB,IAAI,EAAC,MAAM,CAAC;IACZ,iBAAiB,CAAC,EAAC,MAAM,CAAC;CAC7B,CAAA;AAED,qBAAa,IAAI;IACb,SAAS,CAAC,UAAU,mBAAC;IACrB,SAAS,CAAC,MAAM,EAAG,SAAS,CAAC;IAC7B,SAAS,CAAC,QAAQ,WAAC;IAEnB,UAAU;IACV,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC,QAAQ,EAAE,UAAU,EAAC,gBAAgB,EAAE,MAAM,EAAC,SAAS,GAAI,IAAI;IAKpF,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAC,QAAQ,EAAE,UAAU,EAAC,gBAAgB,EAAE,WAAW,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,EAClG,gBAAgB,CAAC,EAAC,MAAM,EAAE,iBAAiB,CAAC,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc,GAAI,IAAI;IAyCzF,MAAM,IAAK,WAAW;IAQtB,OAAO;IAQP,eAAe,CAAC,WAAW,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoB5D,aAAa,CAAC,iBAAiB,CAAC,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoBjE,SAAS,CAAC,KAAK,EAAC,WAAW,EAAE,MAAM,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAwBpE,YAAY,CAAC,aAAa,EAAC,MAAM,EAAE,EAAE,SAAS,CAAC,EAAC,OAAO,EAAE,QAAQ,CAAC,EAAC,cAAc;IAwCjF,UAAU,CAAC,OAAO,EAAC,UAAU,EAAE,EAAE,QAAQ,CAAC,EAAC,cAAc;IAmCzD,aAAa,CAAC,OAAO,EAAC,MAAM,EAAE,EAAE,SAAS,CAAC,EAAC,OAAO,EAAE,QAAQ,CAAC,EAAC,cAAc;IAuC5E,oBAAoB,CAAC,gBAAgB,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoBtE,WAAW,CAAC,QAAQ,CAAC,EAAC,cAAc;IAepC,aAAa,CAAC,QAAQ,CAAC,EAAC,cAAc;IAetC,eAAe,CAAC,cAAc,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAqB/D,UAAU,CAAC,QAAQ,CAAC,EAAC,cAAc;IAenC,KAAK,CAAC,OAAO,EAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAC,cAAc;IAsBhD,iBAAiB,CAAC,cAAc,EAAC,gBAAgB;CAYpD"}
+{"version":3,"file":"vote.d.ts","sourceRoot":"","sources":["../src/vote.ts"],"names":[],"mappings":"AACA,OAAO,EAAc,cAAc,EAAE,gBAAgB,EAAE,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAC,MAAM,YAAY,CAAC;AAKxH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AACpC,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG;IACrB,IAAI,EAAC,MAAM,CAAC;IACZ,iBAAiB,CAAC,EAAC,MAAM,CAAC;CAC7B,CAAA;AAED,qBAAa,IAAI;IACb,SAAS,CAAC,UAAU,mBAAC;IACrB,SAAS,CAAC,MAAM,EAAG,SAAS,CAAC;IAC7B,SAAS,CAAC,QAAQ,WAAC;IAEnB,UAAU;IACV,OAAO;IAKP,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAC,QAAQ,EAAE,UAAU,EAAC,gBAAgB,EAAE,MAAM,EAAC,SAAS,GAAI,IAAI;IAKpF,MAAM,CAAC,GAAG,CAAC,QAAQ,EAAC,QAAQ,EAAE,UAAU,EAAC,gBAAgB,EAAE,WAAW,EAAC,MAAM,EAAE,gBAAgB,EAAC,OAAO,EAAG,IAAI,EAAC,MAAM,EACjH,gBAAgB,CAAC,EAAC,MAAM,EAAE,iBAAiB,CAAC,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc,GAAI,IAAI;IAyCzF,MAAM,IAAK,WAAW;IAQtB,OAAO;IAQP,eAAe,CAAC,WAAW,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoB5D,aAAa,CAAC,iBAAiB,CAAC,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoBjE,SAAS,CAAC,KAAK,EAAC,WAAW,EAAE,MAAM,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAwBpE,YAAY,CAAC,aAAa,EAAC,MAAM,EAAE,EAAE,SAAS,CAAC,EAAC,OAAO,EAAE,QAAQ,CAAC,EAAC,cAAc;IAwCjF,UAAU,CAAC,OAAO,EAAC,UAAU,EAAE,EAAE,QAAQ,CAAC,EAAC,cAAc;IAmCzD,aAAa,CAAC,OAAO,EAAC,MAAM,EAAE,EAAE,SAAS,CAAC,EAAC,OAAO,EAAE,QAAQ,CAAC,EAAC,cAAc;IAuC5E,oBAAoB,CAAC,gBAAgB,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAoBtE,WAAW,CAAC,QAAQ,CAAC,EAAC,cAAc;IAepC,aAAa,CAAC,QAAQ,CAAC,EAAC,cAAc;IAetC,eAAe,CAAC,SAAS,EAAC,OAAO,EAAE,IAAI,EAAC,MAAM,EAAE,QAAQ,CAAC,EAAC,cAAc;IAqBxE,UAAU,CAAC,QAAQ,CAAC,EAAC,cAAc;IAenC,KAAK,CAAC,OAAO,EAAC,MAAM,EAAE,EAAE,QAAQ,CAAC,EAAC,cAAc;IAsBhD,iBAAiB,CAAC,cAAc,EAAC,gBAAgB;CAYpD"}

package/dist/vote.js

@@ -20,15 +20,15 @@ export class Vote {
         v.object = Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
         return v;
     }
-    static New(protocol, permission, description, minutes_duration, max_choice_count, reference_address, passport) {
+    static New(protocol, permission, description, minutes_duration, time, max_choice_count, reference_address, passport) {
         if (!Protocol.IsValidObjects([permission])) {
             ERROR(Errors.IsValidObjects, 'permission');
         }
         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');
@@ -46,15 +46,15 @@ export class Vote {
         if (passport) {
             v.object = txb.moveCall({
                 target: protocol.VoteFn('new_with_passport'),
-                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'),
-                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;
@@ -298,23 +298,23 @@ export class Vote {
             });
         }
     }
-    expand_deadline(minutes_expand, passport) {
-        if (!IsValidUint(minutes_expand)) {
-            ERROR(Errors.IsValidUint, 'minutes_expand');
+    expand_deadline(ms_expand, time, passport) {
+        if (!IsValidUint(time)) {
+            ERROR(Errors.IsValidUint, 'time');
         }
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
                 target: this.protocol.VoteFn('deadline_expand_with_passport'),
-                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'),
-                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)]
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.2.4",
+  "version": "1.2.7",
   "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

@@ -28,7 +28,7 @@ export class Demand {
         this.object = '';
     }
     static New(protocol:Protocol, bounty_type:string, permission:PermissionObject, description:string, 
-        bounty:TransactionResult, passport?:PassportObject) : Demand {
+        bounty:TransactionResult | string, passport?:PassportObject) : Demand {
         if (!Protocol.IsValidObjects([permission, bounty])) {
             ERROR(Errors.IsValidObjects, 'permission, bounty');
         }
@@ -44,13 +44,13 @@ export class Demand {
         if (passport) {
             d.object = txb.moveCall({
                 target:protocol.DemandFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure(description), bounty, Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[passport, txb.pure(description), txb.object(bounty), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[bounty_type],
             })        
         } else {
             d.object = txb.moveCall({
                 target:protocol.DemandFn('new') as FnCallType,
-                arguments:[txb.pure(description), bounty, Protocol.TXB_OBJECT(txb, permission)],
+                arguments:[txb.pure(description), txb.object(bounty), Protocol.TXB_OBJECT(txb, permission)],
                 typeArguments:[bounty_type],
             })        
         }
@@ -92,23 +92,26 @@ export class Demand {
         }
     }
     
-    expand_time(minutes_duration:number, passport?:PassportObject) {
-        if (!IsValidUint(minutes_duration)) {
-            ERROR(Errors.IsValidUint, 'minutes_duration');
+    // minutes_duration TRUE , time is minutes count; otherwise, the deadline time
+    expand_time(minutes_duration:boolean, time: number, passport?:PassportObject) {
+        if (!IsValidUint(time)) {
+            ERROR(Errors.IsValidUint, 'time');
         }
 
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
                 target:this.protocol.DemandFn('time_expand_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_duration, BCS.U64), 
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_duration, BCS.BOOL),
+                    txb.pure(time, BCS.U64), 
                     txb.object(Protocol.CLOCK_OBJECT), Protocol.TXB_OBJECT(txb, this.permission)],
                 typeArguments:[this.bounty_type],
             })  
         } else {
             txb.moveCall({
                 target:this.protocol.DemandFn('time_expand') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_duration, BCS.U64), 
+                arguments:[Protocol.TXB_OBJECT(txb, this.object),  txb.pure(minutes_duration, BCS.BOOL),
+                    txb.pure(time, BCS.U64), 
                     txb.object(Protocol.CLOCK_OBJECT), Protocol.TXB_OBJECT(txb, this.permission)],
                 typeArguments:[this.bounty_type],
             })          
@@ -255,6 +258,17 @@ export class Demand {
         })    
         this.permission = new_permission
     }
+    static parseObjectType = (chain_type:string) : string =>  {
+        if (chain_type) {
+            const s = 'demand::Demand<'
+            const i = chain_type.indexOf(s);
+            if (i > 0) {
+                let r = chain_type.slice(i + s.length, chain_type.length-1);
+                return r
+            }
+        }
+        return '';
+    }
 
     static MAX_BOUNTY_COUNT = 200;
     static MAX_PRESENTERS_COUNT = 200;

package/src/entity.ts

@@ -1,4 +1,4 @@
-import { BCS } from '@mysten/bcs';
+import { BCS, encodeStr, getSuiMoveConfig } from '@mysten/bcs';
 import { Protocol, FnCallType, TxbObject, ResourceAddress, PermissionObject, ResourceObject} from './protocol';
 import { IsValidDesription, IsValidAddress, IsValidName, isValidHttpUrl, Bcs,  } from './utils';
 import { ERROR, Errors } from './exception';
@@ -48,19 +48,26 @@ export class Entity {
         if (info?.homepage && !isValidHttpUrl(info.homepage)) ERROR(Errors.isValidHttpUrl, 'update:homepage');
         if (info?.discord && !IsValidName(info.discord)) ERROR(Errors.IsValidName, 'update:discord');
         
-        let txb = this.protocol.CurrentSession();
+        const txb = this.protocol.CurrentSession();
+        const bytes = Bcs.getInstance().bcs.ser('PersonalInfo', {
+            name:info.name ? new TextEncoder().encode(info.name) :'',
+            description : info?.description ? new TextEncoder().encode(info.description) :  '',
+            avatar : info?.avatar ?? '',
+            twitter : info?.twitter ?? '',
+            discord : info?.discord ?? '',
+            homepage : info?.homepage ?? '',
+        }).toBytes();    
         txb.moveCall({
             target:this.protocol.EntityFn('avatar_update') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(JSON.stringify(info), BCS.STRING)]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure([].slice.call(bytes), 'vector<u8>')]
         })
     }
 
-    create_resource(description:string) : ResourceAddress {
-        if (!IsValidDesription(description)) ERROR(Errors.IsValidDesription, 'create_resource');
+    create_resource() : ResourceAddress {
         let txb = this.protocol.CurrentSession();
         return txb.moveCall({
             target:this.protocol.EntityFn('resource_create') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(description, BCS.STRING)]
+            arguments:[Protocol.TXB_OBJECT(txb, this.object)]
         })
     }
 
@@ -80,4 +87,16 @@ export class Entity {
             arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, resource.get_object()), txb.pure(new_address, BCS.ADDRESS)]
         })   
     }
+
+    query_ent(address_queried:string) {
+        if (!address_queried) {
+            ERROR(Errors.InvalidParam, 'query_ent');
+        }
+
+        const txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.EntityFn('QueryEnt') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(address_queried, BCS.ADDRESS)]
+        })   
+    }
 }

package/src/exception.ts

@@ -5,7 +5,8 @@ export enum Errors {
     IsValidName_AllowEmpty = 'invalid name',
     IsValidEndpoint = 'invalid endpoint',
     IsValidAddress = 'invalid address',
-    IsValidArgType = 'invalid argumentType',
+    IsValidArgType = 'invalid argument type',
+    IsValidTokenType = 'invalid token type',
     IsValidUint = 'invalid uint',
     IsValidInt = 'invalid int', 
     IsValidPercent = 'invalid percent',
@@ -18,6 +19,7 @@ export enum Errors {
     Fail = 'fail',
     IsValidIndentifier = 'indentifier invalid',
     isValidHttpUrl = 'invalid url',
+    IsValidUserDefinedIndex = 'invalid user defined permission index',
     bcsTypeInvalid = 'invalid bcs type',
 }
 

package/src/guard.ts

@@ -194,7 +194,7 @@ export class Guard {
         [MODULES.reward, 'sponsor', 162, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64], 
         [MODULES.reward, 'sponsor_count', 163, [], ValueType.TYPE_U64],
         [MODULES.reward, 'bAllowRepeatClaim', 164, [], ValueType.TYPE_BOOL],  
-        [MODULES.reward, 'claimed_potions_count', 165, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],  
+        [MODULES.reward, 'claimed_portions_count', 165, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64],  
     
         [MODULES.vote, 'permission', 171, [], ValueType.TYPE_ADDRESS],       
         [MODULES.vote, 'bOptions_locked_for_voting', 172, [], ValueType.TYPE_BOOL],

package/src/machine.ts

@@ -247,7 +247,7 @@ export class Machine {
             } else {
                 txb.moveCall({
                     target:this.protocol.MachineFn('repository_remove_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb,  this.object), txb.pure(repositories, 'vector<address>'),
+                    arguments:[passport, Protocol.TXB_OBJECT(txb,  this.object), txb.pure(array_unique(repositories), 'vector<address>'),
                         Protocol.TXB_OBJECT(txb, this.permission)],
                 })
             }   
@@ -260,7 +260,7 @@ export class Machine {
             } else {
                 txb.moveCall({
                     target:this.protocol.MachineFn('repository_remove') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb,  this.object), txb.pure(repositories, 'vector<address>'), 
+                    arguments:[Protocol.TXB_OBJECT(txb,  this.object), txb.pure(array_unique(repositories), 'vector<address>'), 
                         Protocol.TXB_OBJECT(txb, this.permission)],
                 })
             }