wowok 1.2.5 → 1.2.8

package/src/protocol.ts

@@ -79,8 +79,8 @@ export enum OperatorType {
 export enum ValueType {
     TYPE_BOOL = 100,
     TYPE_ADDRESS = 101,
-    TYPE_U64 = 102,
-    TYPE_U8 = 103,
+    TYPE_U8 = 102,
+    TYPE_U64 = 103,
     TYPE_VEC_U8 = 104,
     TYPE_U128 = 105,
     TYPE_VEC_ADDRESS = 106,
@@ -101,6 +101,49 @@ export enum ValueType {
     TYPE_VEC_STRING = 121,
     TYPE_U256 = 122,
 }
+export enum RepositoryValueType {
+    Address = 200,
+    Address_Vec = 201,
+    PositiveNumber = 202,
+    PositiveNumber_Vec = 203,
+    String = 204,
+    String_Vec = 205,
+}
+
+export const RepositoryValueTypeInfo = [
+    {type: RepositoryValueType.String, name:'String', description:'String.'},
+    {type: RepositoryValueType.Address, name:'Address', description:'Object id or Personal address.'},
+    {type: RepositoryValueType.PositiveNumber, name:'Positive number or Zero', description:'Positive number or 0. including u8, u16 ,..., u256'},
+    {type: RepositoryValueType.String_Vec, name:'String vector',  description:'Vector of string.'},
+    {type: RepositoryValueType.Address_Vec, name:'Address vector', description:'Vector of address.'},
+    {type: RepositoryValueType.PositiveNumber_Vec, name:'Positive number or Zero vector', description:'Vector of positive number or 0'},
+]
+
+export const ValueTypeInfo = [
+    {type:ValueType.TYPE_BOOL, name:'bool'},
+    {type:ValueType.TYPE_ADDRESS, name:'address'},
+    {type:ValueType.TYPE_U64, name:'u64'},
+    {type:ValueType.TYPE_U8, name:'u8'},
+    {type:ValueType.TYPE_VEC_U8, name:'vec-u8'},
+    {type:ValueType.TYPE_U128, name:'u128'},
+    {type:ValueType.TYPE_VEC_ADDRESS, name:'vec-address'},
+    {type:ValueType.TYPE_VEC_BOOL, name:'vec-bool'},
+    {type:ValueType.TYPE_VEC_VEC_U8, name:'vec-vec-u8'},
+    {type:ValueType.TYPE_VEC_U64, name:'vec-u64'},
+    {type:ValueType.TYPE_VEC_U128, name:'vec-u128'},
+    {type:ValueType.TYPE_OPTION_ADDRESS, name:'opt-address'},
+    {type:ValueType.TYPE_OPTION_BOOL, name:'opt-bool'},
+    {type:ValueType.TYPE_OPTION_U8, name:'opt-u8'},
+    {type:ValueType.TYPE_OPTION_U64, name:'opt-u64'},
+    {type:ValueType.TYPE_OPTION_U128, name:'opt-u128'},
+    {type:ValueType.TYPE_OPTION_U256, name:'opt-u256'},
+    {type:ValueType.TYPE_OPTION_STRING, name:'opt-string'},
+    {type:ValueType.TYPE_OPTION_VEC_U8, name:'opt-vec-u8'},
+    {type:ValueType.TYPE_VEC_U256, name:'vec-u256'},
+    {type:ValueType.TYPE_STRING, name:'string'},
+    {type:ValueType.TYPE_VEC_STRING, name:'vec-string'},
+    {type:ValueType.TYPE_U256, name:'u256'},
+]
 
 export const OperatorTypeArray = (Object.values(OperatorType) as []).filter((v)=>typeof(v) === 'number') as number[];
 export const ValueTypeArray = (Object.values(ValueType) as []).filter((v)=>typeof(v) === 'number') as number[];
@@ -155,6 +198,23 @@ export enum ENTRYPOINT {
     localnet = 'localnet'
 }
 
+const TESTNET = {
+    package: "0xdf85200f7a9dcac175724d10d1002c7481f718bb8f609f2ff27da47ce5d04870",
+    wowok_object: '0xcbbc4a23b63ab77291e885998ef1d03ac13537bb6b8ffb108913f8196cd7f62b',
+    entity_object: '0x362aa575fa8c1506776f13e8f5849fd932b26b080f7a6f238856f42ce6114e31',
+}
+
+const MAINNET = {
+    package: "",
+    wowok_object: '',
+    entity_object: '',
+}
+
+export interface CoinTypeInfo {
+    symbol: string;
+    type: string;
+    decimals: number;
+}
 export class Protocol {
     protected network = '';
     protected package = '';
@@ -175,6 +235,9 @@ export class Protocol {
             Protocol._instance = new Protocol();
         }; return Protocol._instance
     }
+    static Client() : SuiClient {
+        return  new SuiClient({ url: Protocol.Instance().NetworkUrl() });  
+    }
 
     UseNetwork(network:ENTRYPOINT=ENTRYPOINT.testnet) {
         this.network = network;
@@ -184,12 +247,16 @@ export class Protocol {
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = "0x10edb3f8e11008c8c5cfe951989d10c353d885377fe6cbdfedea3b315fa6b06c";
-                this.wowok_object = '0xb2a940236a1811ff43eaf902e165155687f9c756dcdd1fc70096551bffcb89fc';
-                this.entity_object= '0x8dc27895c123c9736649a800fc58e621b7747d56f0b15a560d09a4412c42ae28';
+                this.package = TESTNET.package;
+                this.wowok_object = TESTNET.wowok_object;
+                this.entity_object= TESTNET.entity_object;
                 this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
             case ENTRYPOINT.mainnet:
+                this.package = MAINNET.package;
+                this.wowok_object = MAINNET.wowok_object;
+                this.entity_object= MAINNET.entity_object;
+                this.graphql = 'https://sui-mainnet.mystenlabs.com/graphql';
                 break;
         };
     }
@@ -212,7 +279,6 @@ export class Protocol {
     };
     
     MachineFn = (fn:any) => { return `${this.package}::${MODULES.machine}::${fn}`};
-    NodeFn = (fn: any) => { return `${this.package}::${MODULES.node}::${fn}`};
     ProgressFn = (fn:any) => { return `${this.package}::${MODULES.progress}::${fn}`};
     CommunityFn = (fn: any) => { return `${this.package}::${MODULES.community}::${fn}`};
     RepositoryFn = (fn:any) => { return `${this.package}::${MODULES.repository}::${fn}`};
@@ -269,29 +335,70 @@ export class Protocol {
     }
 
     // used in service, discount, order, because service has COIN wrapper for TOKEN
-    static SUI_TOKEN_TYPE = '0x2::sui::SUI'; // TOKEN_TYPE
+    static SUI_TOKEN_TYPE = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'; // TOKEN_TYPE
     // used in demand, reward, ...
-    static SUI_COIN_TYPE = '0x2::coin::Coin<0x2::sui::SUI>'; // COIN TYPE
+    static SUI_COIN_TYPE = '0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<0x2::sui::SUI>'; // COIN TYPE
     WOWOK_TOKEN_TYPE = () => { return this.package + '::wowok::WOWOK' }
     WOWOK_COIN_TYPE = () => {  return '0x2::coin::Coin<' + this.package + '::wowok::WOWOK>'}
     COINS_TYPE = () => { 
         switch(this.network) {
             case ENTRYPOINT.testnet:
-                /*return [
-                    {name:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9},
-                    {name:'WOW', type:this.WOWOK_TOKEN_TYPE(), decimals:9},
-                ];*/
+                return this.CoinTypes_Testnet;
             case ENTRYPOINT.mainnet:
-                return [
-                    {name:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9},
-                    {name:'WOW', type:this.WOWOK_TOKEN_TYPE(), decimals:9},
-                    {name:'USDT', type:'0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN', decimals:6},
-                    {name:'USDC', type:'0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN', decimals:6},              
-                    {name:'WETH', type:'0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN', decimals:8},
-                    {name:'WBNB', type:'0xb848cce11ef3a8f62eccea6eb5b35a12c4c2b1ee1af7755d02d7bd6218e8226f::coin::COIN', decimals:8},
-                ];
+                return this.CoinTypes_Mainnet;
         }; return [];
     }
+    Update_CoinType = (token_type: string, decimals:number, symbol: string) => {
+        if (!symbol || !token_type) return ;
+        switch(this.network) {
+            case ENTRYPOINT.testnet:
+                var r = this.CoinTypes_Testnet.filter((v) => v?.type !== token_type);
+                r.push({symbol:symbol, type:token_type, decimals:decimals}); 
+                this.CoinTypes_Testnet = r;
+                break;
+            case ENTRYPOINT.mainnet:
+                var r = this.CoinTypes_Mainnet.filter((v) => v?.type !== token_type);
+                r.push({symbol:symbol, type:token_type, decimals:decimals}); 
+                this.CoinTypes_Mainnet = r;
+                break;
+        }; 
+    }
+    ExplorerUrl = (objectid: string, type:'object' | 'txblock' | 'account'='object') => {
+        if (this.network === ENTRYPOINT.testnet) {
+            return 'https://testnet.suivision.xyz/' + type + '/' + objectid;
+        } else if (this.network === ENTRYPOINT.mainnet) {
+            return 'https://suivision.xyz/' + type + '/' + objectid;
+        }; return ''
+    }
+
+    CoinTypes_Testnet:CoinTypeInfo[] = [
+        {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9},
+        {symbol:'SUI', type:'0x2::sui::SUI', decimals:9},
+        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+        {symbol:'USDT', type:'0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN', decimals:6},
+        {symbol:'USDC', type:'0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN', decimals:6},              
+        {symbol:'WETH', type:'0xaf8cd5edc19c4512f4259f0bee101a40d41ebed738ade5874359610ef8eeced5::coin::COIN', decimals:8},
+        {symbol:'WBNB', type:'0xb848cce11ef3a8f62eccea6eb5b35a12c4c2b1ee1af7755d02d7bd6218e8226f::coin::COIN', decimals:8},
+    ];
+
+    CoinTypes_Mainnet:CoinTypeInfo[] = [
+    ];
+
+    GetCoinTypeInfo = (token_type: string, handler:(info:CoinTypeInfo)=>void) : CoinTypeInfo | 'loading' => {
+        let r = this.COINS_TYPE().find((v) => v?.type === token_type);
+        if (!r) {
+            Protocol.Client().getCoinMetadata({coinType:token_type}).then((res) => {
+                if (res?.decimals && res?.symbol) {
+                    this.Update_CoinType(token_type, res?.decimals, res?.symbol); 
+                    handler({symbol:res.symbol, decimals:res.decimals, type:token_type});
+                }
+            }).catch((e) => {
+                console.log(e);
+            })
+        } else {
+            return r;
+        }; return 'loading';
+    }
 
     static CLOCK_OBJECT = Inputs.SharedObjectRef({
         objectId:"0x6",
@@ -316,6 +423,7 @@ export class Protocol {
     WOWOK_OBJECTS_PREFIX_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
         { return this.package + '::' + key + '::'; })
     object_name_from_type_repr = (type_repr:string) : string => {
+        if (!type_repr) return ''
         let i = type_repr.indexOf('::');
         if (i > 0 && type_repr.slice(0, i) === this.package) {
             i = type_repr.indexOf('<');
@@ -339,6 +447,7 @@ export class RpcResultParser {
         return names;
     }
     static objectids_from_response = (protocol:Protocol, response:SuiTransactionBlockResponse, concat_result?:Map<string, TxbObject[]>): Map<string, TxbObject[]> => {
+        // console.log(response)
         let ret = new Map<string, string[]>();
         if (response?.objectChanges) {
             response.objectChanges.forEach((change) => {

package/src/repository.ts

@@ -1,18 +1,27 @@
 import { BCS } from '@mysten/bcs';
-import { Protocol, FnCallType, ValueType, RepositoryObject, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
+import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress, PermissionObject, PassportObject, TxbObject} from './protocol';
 import { PermissionIndexType, Permission } from './permission'
-import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone,  } from './utils';
+import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, OptionNone, IsValidName,  ValueTypeConvert} from './utils';
 import { ERROR, Errors } from './exception';
-import { Resource } from './resource';
+import { MAX_U8, MAX_U128, MAX_U256, MAX_U64 } from './utils';
 
 export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
     POLICY_MODE_STRICT = 1,
 }
+
+export interface RepData {
+    id: string;
+    name: string;
+    dataType: RepositoryValueType;
+    data: string | string[];
+    object: string;
+}
+
 export type Repository_Policy = {
     key:string;
     description: string;
-    value_type: ValueType;
+    data_type: RepositoryValueType;
     permission?: PermissionIndexType; // PermissionIndex like, must be geater than 10000
 }
 export type Repository_Policy_Data = {
@@ -141,12 +150,9 @@ export class Repository {
         })  
     }
     add_reference(references:string[], passport?:PassportObject) {
-        if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
-        }
-
+        if (references.length === 0)  return;
         if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+            ERROR(Errors.IsValidArray, 'add_reference')
         }
 
         let txb = this.protocol.CurrentSession();
@@ -167,12 +173,10 @@ export class Repository {
         }
     }
     remove_reference(references:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
-        }
+        if (references.length === 0 && !removeall)  return
 
         if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+            ERROR(Errors.IsValidArray, 'remove_reference')
         }
 
         let txb = this.protocol.CurrentSession();
@@ -210,9 +214,7 @@ export class Repository {
     }
     // add or modify the old 
     add_policies(policies:Repository_Policy[], passport?:PassportObject)  {
-        if (!policies) {
-            ERROR(Errors.InvalidParam, 'policies')
-        }
+        if (policies.length === 0) return;
 
         let bValid = true;
         policies.forEach((p) => {
@@ -233,7 +235,7 @@ export class Repository {
                     arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
                         txb.pure(policy.key), 
                         txb.pure(policy.description),
-                        permission_index, txb.pure(policy.value_type, BCS.U8),
+                        permission_index, txb.pure(policy.data_type, BCS.U8),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 })              
             } else {
@@ -242,53 +244,59 @@ export class Repository {
                     arguments:[Protocol.TXB_OBJECT(txb, this.object), 
                         txb.pure(policy.key), 
                         txb.pure(policy.description),
-                        permission_index, txb.pure(policy.value_type, BCS.U8),
+                        permission_index, txb.pure(policy.data_type, BCS.U8),
                         Protocol.TXB_OBJECT(txb, this.permission)]
                 })  
             }
         });    
     }
 
-    remove_policies(policy_keys:string[], removeall?:boolean, passport?:PassportObject)  {
-        if (!removeall && !policy_keys) {
-            ERROR(Errors.AllInvalid, 'policy_keys & removeall')
-        }
-        if (policy_keys && !IsValidArray(policy_keys, Repository.IsValidName)){
+    remove_policies(policy_keys:string[], passport?:PassportObject)  {
+        if (policy_keys.length === 0) return ;
+        if (!IsValidArray(policy_keys, Repository.IsValidName)){
             ERROR(Errors.InvalidParam, 'policy_keys')
         }
 
         let txb = this.protocol.CurrentSession();
         if (passport) {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_all_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)]
-                })          
-            } else {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
-                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)]
-                })                
-            }
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_remove_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })                
         } else {
-            if (removeall) {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove_all') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), Protocol.TXB_OBJECT(txb, this.permission)]
-                })          
-            } else {
-                txb.moveCall({
-                    target:this.protocol.RepositoryFn('policy_remove') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(txb, this.object), 
-                        txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
-                        Protocol.TXB_OBJECT(txb, this.permission)]
-                })                
-            }
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_remove') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(Bcs.getInstance().ser(ValueType.TYPE_VEC_STRING, array_unique(policy_keys))), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })                     
         }
-        
     }
+    rename_policy(policy_key:string, new_policy_key:string, passport?:PassportObject) {
+        if (!IsValidName(policy_key) || !IsValidName(new_policy_key)) {
+            ERROR(Errors.IsValidName, 'change_policy')
+        }
+
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_rename_with_passport') as FnCallType,
+                arguments:[passport, Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(policy_key), txb.pure(new_policy_key), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })     
+        } else {
+            txb.moveCall({
+                target:this.protocol.RepositoryFn('policy_rename') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), 
+                    txb.pure(policy_key), txb.pure(new_policy_key), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })       
+        }
+    }
+
     // PermissionIndex.description_set
     set_description(description:string, passport?:PassportObject)  {
         if (!IsValidDesription(description)){
@@ -347,7 +355,6 @@ export class Repository {
                     Protocol.TXB_OBJECT(txb, this.permission)]
             })   
         } 
-        
     }
 
     set_policy_permission(policy:string, permission_index?:number, passport?:PassportObject)  {
@@ -376,7 +383,6 @@ export class Repository {
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), index, Protocol.TXB_OBJECT(txb, this.permission)]
             })   
         }     
-        
     }
 
     change_permission(new_permission:PermissionObject) {
@@ -392,14 +398,115 @@ export class Repository {
         this.permission = new_permission  
     }
 
-    static MAX_POLICY_COUNT = 1000;
+    static MAX_POLICY_COUNT = 200;
     static MAX_KEY_LENGTH = 128;
     static MAX_VALUE_LENGTH = 204800;
+    static MAX_REFERENCE_COUNT = 100;
     static IsValidName = (key:string)  => {
         return key.length <= Repository.MAX_KEY_LENGTH && key.length != 0;
     }
     static IsValidValue = (value:Uint8Array)  => {
         return value.length < Repository.MAX_VALUE_LENGTH;
     }
+    static parseObjectType = (chain_type:string) : string =>  {
+        if (chain_type) {
+            const s = 'repository::Repository<'
+            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 rpc_de_data(fields:any) : RepData [] {
+        const rep: RepData[] = fields?.map((v:any) => {
+            const value = new Uint8Array((v?.data?.content?.fields as any)?.value);
+            const type = value?.length > 0 ? value[0] as ValueType : null;
+            var d : any = value.length > 0 ? value.slice(1) : Uint8Array.from([]);
+            if (type === ValueType.TYPE_STRING) {
+                d = Bcs.getInstance().de(ValueType.TYPE_VEC_U8, d);
+                d = new TextDecoder().decode(Uint8Array.from(d));
+            } else if (type === ValueType.TYPE_VEC_STRING) {
+                d = Bcs.getInstance().de(ValueType.TYPE_VEC_VEC_U8, d) as [];
+                d = d.map((i:any) => {
+                    return new TextDecoder().decode(Uint8Array.from(i));
+                })
+            } else {
+                d = Bcs.getInstance().de(value[0], d);
+                if (type === ValueType.TYPE_ADDRESS) {
+                    d = '0x' + d;
+                } else if (type === ValueType.TYPE_VEC_ADDRESS) {
+                    d = d.map((v:string) => { return ('0x' + v) } );
+                }
+            };
+            return {object:v?.data?.content?.fields?.id?.id, id:(v?.data?.content?.fields as any)?.name?.fields?.id, 
+                name:(v?.data?.content?.fields as any)?.name?.fields?.key, 
+                data:d, dataType: ValueTypeConvert(type)
+            }
+        });
+        return rep;
+    }
+
+    static DataType2ValueType(data:string) : ValueType | undefined{
+        try {
+            const value = BigInt(data);
+            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
+    }
+
+    static ResolveRepositoryData = (dataType:RepositoryValueType, data:string | string[]) : {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) {
+            const t = Repository.DataType2ValueType(data as string);
+            if (!t) return undefined;
+            return {type:t, data:Bcs.getInstance().ser(t, data)}
+       } else if (dataType === RepositoryValueType.Address) {
+            if (!IsValidAddress(data as string)) return undefined;
+            return {type:ValueType.TYPE_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_ADDRESS, data)}
+       } else if (dataType === RepositoryValueType.Address_Vec) {
+            for(let i = 0; i < (data as string[]).length; ++i) {
+                if (!IsValidAddress((data as string[])[i])) return undefined; 
+            }
+            return {type:ValueType.TYPE_VEC_ADDRESS, data:Bcs.getInstance().ser(ValueType.TYPE_VEC_ADDRESS, data)}
+       } else if (dataType === RepositoryValueType.PositiveNumber_Vec) {
+            let type = ValueType.TYPE_U8;
+            for(let i = 0; i < (data as string[]).length; ++i) {
+                const t = Repository.DataType2ValueType(data as string);
+                if (!t) return undefined;
+                if (t > type) type = t;
+            }
+            if (type === ValueType.TYPE_U8) { 
+                type  = ValueType.TYPE_VEC_U8;
+            } else if (type === ValueType.TYPE_U64) {
+                type = ValueType.TYPE_VEC_U64;
+            } else if (type === ValueType.TYPE_U128) {
+                type = ValueType.TYPE_VEC_U128;
+            } else {
+                type = ValueType.TYPE_VEC_U256;
+            }
+            return {type:type, data:Bcs.getInstance().ser(type, data)}
+       } else if (dataType === RepositoryValueType.String_Vec) {
+            const r = (data as string[]).map((v:string) => {
+                return new TextEncoder().encode(v);
+            })
+            return {type: ValueType.TYPE_VEC_STRING, data: Bcs.getInstance().ser(ValueType.TYPE_VEC_VEC_U8, r)}
+       }
+       return undefined
+    }
 }