wowok 1.2.5 → 1.2.7

package/src/permission.ts

@@ -1,6 +1,6 @@
 import { BCS } from '@mysten/bcs';
 import { FnCallType, TxbObject, PermissionObject, PermissionAddress, GuardObject, Protocol} from './protocol';
-import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUint, Bcs} from './utils';
+import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUint, Bcs, IsValidName} from './utils';
 import { ERROR, Errors } from './exception';
 import { ValueType } from './protocol';
 
@@ -9,12 +9,13 @@ export enum PermissionIndex {
     repository_set_description_set = 101,
     repository_set_policy_mode = 102,
     repository_add_policies = 103,
-    repository_remove_policies = 104,
+    repository_remove_policies = 103,
     repository_set_policy_description = 105,
     repository_set_policy_permission = 106,
     repository_reference_add = 107,
-    repository_reference_remove = 108,
-    repository_reference_removeall = 108,
+    repository_reference_remove = 107,
+    repository_reference_removeall = 107,
+
     vote = 150,
     vote_set_description = 151,
     vote_set_reference = 152, 
@@ -27,19 +28,23 @@ export enum PermissionIndex {
     vote_lock_deadline = 159,
     vote_expand_deadline = 160,
     vote_lock_guard = 161,
+
     service = 200,
     service_set_description = 201,
     service_set_price = 202,
     service_set_stock = 203,
     service_add_stock = 203,
     service_reduce_stock = 203,
+    service_set_sale_endpoint = 204,
     service_set_payee = 205,
     service_repository_add = 206,
     service_repository_remove = 207,
     service_add_withdraw_guards = 208,
     service_remove_withdraw_guards  = 208,
+    service_removeall_withdraw_guards  = 208,
     service_add_refund_guards = 210,
     service_remove_refund_guards = 210,
+    service_removeall_refund_guards = 210,
     service_add_sales = 212,
     service_remove_sales = 213,
     service_discount_transfer = 214,
@@ -54,11 +59,12 @@ export enum PermissionIndex {
     service_change_required_pubkey = 222,
     service_change_order_required_pubkey = 224,
     service_pause = 225,
+
     reward = 240,
     reward_refund = 241,
     reward_expand_time = 242,
     reward_add_guard = 243,
-    reward_remove_guard = 244,
+    reward_remove_guard = 243,
     reward_set_description = 245,
     reward_lock_guards = 246,
     demand = 260,
@@ -86,6 +92,94 @@ export enum PermissionIndex {
     user_defined_start = 10000,
 }
 
+export interface PermissionInfoType {
+    index: number;
+    name:string;
+    description:string;
+    module: string;
+    guard?: string;
+}
+
+export const PermissionInfo : PermissionInfoType[] = [
+    {index:PermissionIndex.repository, name:'Repository', description:'repository', module: 'repository'},
+    {index:PermissionIndex.repository_set_description_set, name:'Description', description:'repository_set_description_set', module: 'repository'},
+    {index:PermissionIndex.repository_set_policy_mode, name:'Policy mode', description:'repository_set_policy_mode', module: 'repository'},
+    {index:PermissionIndex.repository_add_policies, name:'Add Policy', description:'brepository_add_policies', module: 'repository'},
+    {index:PermissionIndex.repository_remove_policies, name:'Remove Policy', description:'build machine', module: 'repository'},
+    {index:PermissionIndex.repository_set_policy_description, name:'Policy Description', description:'build machine', module: 'repository'},
+    {index:PermissionIndex.repository_set_policy_permission, name:'Policy Permission', description:'build machine',  module: 'repository'},
+    {index:PermissionIndex.repository_reference_add, name:'Add Reference', description:'build machine', module: 'repository'},
+    {index:PermissionIndex.repository_reference_remove, name:'Remove Reference', description:'build machine', module: 'repository'},
+
+    {index:PermissionIndex.vote, name:'Vote', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_set_description, name:'Description', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_set_reference, name:'Reference', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_add_guard, name:'Add Guard', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_remove_guard, name:'Remove Guard', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_add_option, name:'Add Option', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_remove_option, name:'Remove Option', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_set_max_choice_count, name:'Choice count', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_open_voting, name:'Open voting', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_lock_deadline, name:'Lock deadline', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_expand_deadline, name:'Expand deadline', description:'build machine', module: 'vote'},
+    {index:PermissionIndex.vote_lock_guard, name:'Lock Guard', description:'build machine', module: 'vote'},
+
+    {index:PermissionIndex.service, name:'Service', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_description, name:'Description', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_price, name:'Price', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_stock, name:'Inventory', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_payee, name:'Payee', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_repository_add, name:'Add Repository', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_repository_remove, name:'Remove Repository', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_add_withdraw_guards, name:'Withdraw Guard', description:'Add, remove withdraw guards', module: 'service'},
+    {index:PermissionIndex.service_add_refund_guards, name:'Refund Guard', description:'Add, remove refund guards', module: 'service'},
+    {index:PermissionIndex.service_remove_refund_guards, name:'Remove Refund Guard', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_add_sales, name:'Add sales', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_remove_sales, name:'Remove sales', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_discount_transfer, name:'Discount', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_withdraw, name:'Withdraw', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_buy_guard, name:'Buyer Guard', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_machine, name:'Machine', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_endpoint, name:'Endpoint', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_publish, name:'Publish', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_clone, name:'Clone', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_set_customer_required, name:'Buyer info', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_change_order_required_pubkey, name:'Order pubkey', description:'build machine', module: 'service'},
+    {index:PermissionIndex.service_pause, name:'Pause', description:'build machine', module: 'service'},
+
+    {index:PermissionIndex.reward, name:'Reward', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_refund, name:'Refund', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_expand_time, name:'Expand deadline', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_add_guard, name:'Add Guard', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_remove_guard, name:'Remove Guard', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_set_description, name:'Description', description:'build machine', module: 'reward'},
+    {index:PermissionIndex.reward_lock_guards, name:'Lock Guard', description:'build machine', module: 'reward'},
+
+    {index:PermissionIndex.demand, name:'Demand', description:'build machine', module: 'demand'},
+    {index:PermissionIndex.demand_refund, name:'Refund', description:'build machine', module: 'demand'},
+    {index:PermissionIndex.demand_expand_time, name:'Expand deadline', description:'build machine', module: 'demand'},
+    {index:PermissionIndex.demand_set_guard, name:'Guard', description:'build machine', module: 'demand'},
+    {index:PermissionIndex.demand_set_description, name:'Description', description:'build machine', module: 'demand'},
+    {index:PermissionIndex.demand_yes, name:'Yes', description:'build machine', module: 'demand'},
+
+    {index:PermissionIndex.machine, name: 'Machine', description:'build machine', module: 'machine'},
+    {index:PermissionIndex.machine_set_description, name: 'Description', description:'machine_set_description', module: 'machine'},
+    {index:PermissionIndex.machine_add_repository, name: 'Add Repository', description:'machine_add_repository', module: 'machine'},
+    {index:PermissionIndex.machine_remove_repository, name: 'Remove Repository', description:'machine_remove_repository', module: 'machine'},
+    {index:PermissionIndex.machine_clone, name: 'Clone', description:'machine_clone', module: 'machine'},
+    {index:PermissionIndex.machine_add_node, name: 'Add node', description:'machine_add_node/2', module: 'machine'},
+    {index:PermissionIndex.machine_remove_node, name: 'Remove node', description:'machine_remove_node', module: 'machine'},
+    {index:PermissionIndex.machine_set_endpoint, name: 'Endpoint', description:'machine_set_endpoint', module: 'machine'},
+    {index:PermissionIndex.machine_pause, name: 'Pause', description:'machine_pause', module: 'machine'},
+    {index:PermissionIndex.machine_publish, name: 'Publish', description:'machine_publish', module: 'machine'},
+
+    {index:PermissionIndex.progress, name: 'Progress', description:'build progress', module: 'progress'},
+    {index:PermissionIndex.progress_set_namedOperator, name: 'Operator', description:'progress_set_namedOperator', module: 'progress'},
+    {index:PermissionIndex.progress_bind_task, name: 'Bind', description:'progress_bind_task', module: 'progress'},
+    {index:PermissionIndex.progress_set_context_repository, name: 'Repository', description:'progress_set_context_repository', module: 'progress'},
+    {index:PermissionIndex.progress_unhold, name: 'Unhold', description:'progress_unhold', module: 'progress'},
+]
+
 export type PermissionIndexType = PermissionIndex | number;
 
 export type Permission_Index = {
@@ -141,10 +235,71 @@ export class  Permission {
             arguments: [Protocol.TXB_OBJECT(txb, this.object)],
         })  
     }
+    add_userdefine(index: number, name:string) {
+        if (!Permission.IsValidUserDefinedIndex(index)) {
+            ERROR(Errors.IsValidUserDefinedIndex, 'add_userdefine');
+        }
+
+        if (!IsValidName(name)) {
+            ERROR(Errors.IsValidName, 'add_userdefine');
+        }
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.PermissionFn('user_define_add') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64), txb.pure(name, BCS.STRING)]
+        })   
+    }
+    
+    remove_userdefine(index: number) {
+        if (!Permission.IsValidUserDefinedIndex(index)) {
+            ERROR(Errors.IsValidUserDefinedIndex, 'add_userdefine');
+        }
+
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.PermissionFn('user_define_remove') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64)]
+        })   
+    }
+
+    change_entity(old_entity: string, new_entity: string) {
+        if (!IsValidAddress(old_entity) || !IsValidAddress(new_entity)) {
+            ERROR(Errors.IsValidAddress, 'change_entity')
+        }
+        let txb = this.protocol.CurrentSession();
+        txb.moveCall({
+            target:this.protocol.PermissionFn('change_entity') as FnCallType,
+            arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(old_entity, BCS.ADDRESS), 
+                txb.pure(new_entity, BCS.ADDRESS) ]
+        })     
+    }
+
+    add_entity2(entities: string[], index?:PermissionIndexType) {
+        if (!entities) {
+            ERROR(Errors.InvalidParam, 'add_entity2');
+        }
+        if (!IsValidArray(entities, IsValidAddress)) {
+            ERROR(Errors.IsValidArray, 'add_entity2');
+        }
+
+        let txb = this.protocol.CurrentSession();
+        if (index) {
+            txb.moveCall({
+                target:this.protocol.PermissionFn('add_with_index') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(index, BCS.U64),
+                    txb.pure(array_unique(entities), 'vector<address>')]
+            })       
+        } else {
+            txb.moveCall({
+                target:this.protocol.PermissionFn('add') as FnCallType,
+                arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(array_unique(entities), 'vector<address>')]
+            })                   
+        }
+    }
 
     add_entity(entities:Permission_Entity[])  {
         if (!entities) {
-            ERROR(Errors.InvalidParam, 'entities');
+            ERROR(Errors.InvalidParam, 'add_entity');
         }
 
         let bValid = true;
@@ -179,13 +334,13 @@ export class  Permission {
                     }
                 }      
             }    
-            if (indexes.length > 0) {
+            //if (indexes.length > 0) {
                 txb.moveCall({
                     target:this.protocol.PermissionFn('add_batch') as FnCallType,
                     arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity.entity_address, BCS.ADDRESS), 
                         txb.pure(indexes, 'vector<u64>')]
                 })            
-            }
+            //}
         } 
         // set guards
         guards.forEach(({entity_address, index, guard}) => {
@@ -219,8 +374,7 @@ export class  Permission {
                 arguments:[Protocol.TXB_OBJECT(txb, this.object), txb.pure(entity_address, BCS.ADDRESS), 
                     txb.pure(index, BCS.U64)]
             })       
-        }
-        ;
+        };
     }
 
     remove_index(entity_address:string, index:PermissionIndexType[])  {
@@ -314,6 +468,7 @@ export class  Permission {
     static MAX_ADMIN_COUNT = 64;
     static MAX_ENTITY_COUNT = 2000;
     static MAX_PERMISSION_INDEX_COUNT = 200;
+    static MAX_PERSONAL_PERMISSION_COUNT = 200; 
     static IsValidUserDefinedIndex = (index:number)  => { 
         return index >= PermissionIndex.user_defined_start && IsValidUint(index)
     }

package/src/protocol.ts

@@ -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.Address, name:'Address', description:'Object id or Personal address.'},
+    {type: RepositoryValueType.Address_Vec, name:'Address vector', description:'Vector of address.'},
+    {type: RepositoryValueType.String, name:'String', description:'String.'},
+    {type: RepositoryValueType.String_Vec, name:'String vector',  description:'Vector of string.'},
+    {type: RepositoryValueType.PositiveNumber, name:'Positive number', description:'Positive number. including u8, u16 ,..., u256'},
+    {type: RepositoryValueType.PositiveNumber_Vec, name:'Positive number vector', description:'Vector of positive number'},
+]
+
+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: "0x852fa17575b1ae11932b475110bf46981458fdb67a2f07b922022e1516560fad",
+    wowok_object: '0xf98cc6d8bd9feadc5dce7365270b4ffb32f69a5320ab739193d301103e686e8c',
+    entity_object: '0xe0469c187499273ec39a575cc28d4d93f0a66b11e1b92028c61bc69bfc1167c6',
+}
+
+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;
         };
     }
@@ -269,29 +336,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 +424,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 +448,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,7 +1,7 @@
 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,  } from './utils';
 import { ERROR, Errors } from './exception';
 import { Resource } from './resource';
 
@@ -9,10 +9,12 @@ export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
     POLICY_MODE_STRICT = 1,
 }
+
+
 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 = {
@@ -142,13 +144,13 @@ export class Repository {
     }
     add_reference(references:string[], passport?:PassportObject) {
         if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
+            ERROR(Errors.InvalidParam, 'add_reference')
         }
 
         if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+            ERROR(Errors.IsValidArray, 'add_reference')
         }
-
+        console.log(array_unique(references))
         let txb = this.protocol.CurrentSession();
         if (passport) {
             txb.moveCall({
@@ -167,12 +169,12 @@ export class Repository {
         }
     }
     remove_reference(references:string[], removeall?:boolean, passport?:PassportObject) {
-        if (!references) {
-            ERROR(Errors.InvalidParam, 'references')
+        if (!references && !removeall) {
+            ERROR(Errors.InvalidParam, 'remove_reference')
         }
 
-        if (!IsValidArray(references, IsValidAddress)) {
-            ERROR(Errors.IsValidArray, 'references')
+        if (references && !IsValidArray(references, IsValidAddress)) {
+            ERROR(Errors.IsValidArray, 'remove_reference')
         }
 
         let txb = this.protocol.CurrentSession();
@@ -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,15 +244,15 @@ 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) {
+    remove_policies(policy_keys:string[], passport?:PassportObject)  {
+        if (!policy_keys) {
             ERROR(Errors.AllInvalid, 'policy_keys & removeall')
         }
         if (policy_keys && !IsValidArray(policy_keys, Repository.IsValidName)){
@@ -259,36 +261,44 @@ export class Repository {
 
         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, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    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, BCS.STRING), txb.pure(new_policy_key, BCS.STRING), 
+                    Protocol.TXB_OBJECT(txb, this.permission)]
+            })       
+        }
+    }
+
     // PermissionIndex.description_set
     set_description(description:string, passport?:PassportObject)  {
         if (!IsValidDesription(description)){
@@ -347,7 +357,6 @@ export class Repository {
                     Protocol.TXB_OBJECT(txb, this.permission)]
             })   
         } 
-        
     }
 
     set_policy_permission(policy:string, permission_index?:number, passport?:PassportObject)  {
@@ -376,7 +385,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 +400,26 @@ 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 '';
+    }
 }