wowok 1.4.23 → 1.4.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wowok",
-  "version": "1.4.23",
+  "version": "1.4.27",
   "description": "Create, collaborate, and transact on your own terms with the AI-driven web3 collaboration protocol.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
@@ -36,7 +36,10 @@
     "grantor",
     "grantee",
     "move language",
-    "move"
+    "move",
+    "treasury",
+    "payment",
+    "Withholding"
   ],
   "author": "wowok",
   "license": "Apache-2.0",

package/src/demand.ts

@@ -1,6 +1,6 @@
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject, ResourceObject} from './protocol';
-import { IsValidDesription, IsValidUintLarge, IsValidAddress, IsValidArgType, } from './utils'
+import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject } from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidArgType, IsValidU64, parseObjectType } from './utils'
 import { Errors, ERROR}  from './exception'
 
 export class Demand {
@@ -35,7 +35,7 @@ export class Demand {
         if (!IsValidArgType(bounty_type)) {
             ERROR(Errors.IsValidArgType, bounty_type);
         }
-        if (!IsValidUintLarge(time)) {
+        if (!IsValidU64(time)) {
             ERROR(Errors.IsValidUint, 'time')
         }
         
@@ -95,7 +95,7 @@ export class Demand {
     
     // minutes_duration TRUE , time is minutes count; otherwise, the deadline time
     expand_time(minutes_duration:boolean, time: number, passport?:PassportObject) {
-        if (!IsValidUintLarge(time)) {
+        if (!IsValidU64(time)) {
             ERROR(Errors.IsValidUint, 'time');
         }
         const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
@@ -250,16 +250,8 @@ 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 parseObjectType = (chain_type?:string | null) : string =>  {
+        return parseObjectType(chain_type, 'demand::Demand<')
     }
 
     static MAX_BOUNTY_COUNT = 300;

package/src/guard.ts

@@ -250,31 +250,32 @@ export class Guard {
         [MODULES.vote, 'Vote-Guard Wight', 1110, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The voting weight corresponding to the Vote-Guard.', ['guard address']],   
         [MODULES.vote, 'Has Voted by Address', 1111, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Whether an address has already voted?', ['address']], 
         [MODULES.vote, 'Voted Weight by Address', 1112, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The weight of whether an address has been voted on.', ['adddress']], 
-        [MODULES.vote, 'Has Option', 1113, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option is included?', ['option name']],
-        [MODULES.vote, 'Has Object of Option', 1114, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option refers to an object?', ['option name']],   
-        [MODULES.vote, 'Option Object', 1115, [ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The object referenced by a voting option.', ['option name']], 
-        [MODULES.vote, 'Option Counts', 1116, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of votes for the voting option.', ['option name']], 
-        [MODULES.vote, 'Option Votes', 1117, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of voted addresses for the voting option.', ['option name']], 
+        [MODULES.vote, 'Has Option', 1113, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option is included?', ['option content']],
+        [MODULES.vote, 'Has Object of Option', 1114, [ValueType.TYPE_STRING], ValueType.TYPE_BOOL, 'Whether a voting option refers to an object?', ['option content']],   
+        [MODULES.vote, 'Option Object', 1115, [ValueType.TYPE_STRING], ValueType.TYPE_ADDRESS, 'The object referenced by a voting option.', ['option content']], 
+        [MODULES.vote, 'Option Counts', 1116, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of votes for the voting option.', ['option content']], 
+        [MODULES.vote, 'Option Votes', 1117, [ValueType.TYPE_STRING], ValueType.TYPE_U64, 'The number of voted addresses for the voting option.', ['option content']], 
         [MODULES.vote, 'Address Count Voted', 1118, [], ValueType.TYPE_U64, 'Total number of addresses voted.', []],   
-        [MODULES.vote, 'Top1 Option by Addresses', 1119, [], ValueType.TYPE_STRING, 'The name of the voting option ranked first by the number of voting addresses.', []], 
+        [MODULES.vote, 'Top1 Option by Addresses', 1119, [], ValueType.TYPE_STRING, 'The content of the voting option ranked first by the number of voting addresses.', []], 
         [MODULES.vote, 'Top1 Counts by Addresses', 1120, [], ValueType.TYPE_U64, 'Number of votes for the top voting option by number of voting addresses.', []], 
-        [MODULES.vote, 'Top1 Option by Votes', 1121, [], ValueType.TYPE_STRING, 'The name of the voting option ranked first by the number of votes.', []], 
+        [MODULES.vote, 'Top1 Option by Votes', 1121, [], ValueType.TYPE_STRING, 'The content of the voting option ranked first by the number of votes.', []], 
         [MODULES.vote, 'Top1 Counts by Votes', 1122, [], ValueType.TYPE_U64, 'Number of votes for the top voting option by number of votes.', []], 
-
+        [MODULES.vote, 'Voted Time by Address', 1113, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The time of whether an address has been voted on.', ['adddress']], 
+ 
         [MODULES.payment, 'Sender', 1200, [], ValueType.TYPE_ADDRESS, 'Payment originator address.', []], 
-        [MODULES.payment, 'Total Amount', 1201, [], ValueType.TYPE_U64, "Payment amount.", []], 
-        [MODULES.payment, 'Tips', 1202, [], ValueType.TYPE_STRING, 'Payment remarks.', ['address']], 
+        [MODULES.payment, 'Total Amount', 1201, [], ValueType.TYPE_U128, "Payment amount.", []], 
+        [MODULES.payment, 'Remark', 1202, [], ValueType.TYPE_STRING, 'Payment remark.', ['address']], 
         [MODULES.payment, 'Has Guard for Perpose', 1203, [], ValueType.TYPE_BOOL, 'Whether the payment references a Guard?', []], 
         [MODULES.payment, 'Has Object for Perpose', 1204, [], ValueType.TYPE_BOOL, 'Whether the payment references an Object?', []], 
         [MODULES.payment, 'Guard for Perpose', 1205, [], ValueType.TYPE_ADDRESS, 'The Guard referenced by this payment.', []], 
         [MODULES.payment, 'Object for Perpose', 1206, [], ValueType.TYPE_ADDRESS, "The Object referenced by this payment.", []], 
-        [MODULES.payment, 'Number of Transfer', 1207, [], ValueType.TYPE_U64, 'Number of recipients to receive payment from.', []], 
+        [MODULES.payment, 'Number of Recipients', 1207, [], ValueType.TYPE_U64, 'Number of recipients to receive payment from.', []], 
         [MODULES.payment, 'Is a Recipient', 1208, [ValueType.TYPE_ADDRESS], ValueType.TYPE_BOOL, 'Is a recipient received the payment?', ['address']], 
         [MODULES.payment, 'Amount for a Recipient', 1209, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The amount of payment received by an address.', ['address']], 
         [MODULES.payment, 'Time', 1210, [], ValueType.TYPE_U64, 'Payment time', []], 
         [MODULES.payment, 'Is from Treasury', 1211, [], ValueType.TYPE_BOOL, 'Whether the payment comes from a Treasury?', []], 
         [MODULES.payment, 'Treasury Address', 1212, [], ValueType.TYPE_ADDRESS, 'The Treasury from which the payment comes.', []], 
-        [MODULES.payment, 'Index', 1213, [], ValueType.TYPE_U64, 'Payment index or id.', []], 
+        [MODULES.payment, 'Biz-ID', 1213, [], ValueType.TYPE_U64, 'Bisiness ID number of the payment.', []], 
 
         [MODULES.withholding, 'Amount', 1300, [], ValueType.TYPE_U64, 'Total amount deposited with withholding.' , []], 
         [MODULES.withholding, 'Original Type Deposited', 1301, [], ValueType.TYPE_STRING, "Original type name of asserts deposited.", []], 
@@ -295,11 +296,10 @@ export class Guard {
         [MODULES.treasury, 'Permission', 1400, [], ValueType.TYPE_ADDRESS, 'Permission object address.', []], 
         [MODULES.treasury, 'Balance', 1401, [], ValueType.TYPE_U64, "Treasury balance.", []], 
         [MODULES.treasury, 'Number of Flow Records', 1402, [], ValueType.TYPE_U64, 'Number of treasury transactions.', []], 
-        [MODULES.treasury, 'Deposit Flow', 1403, [], ValueType.TYPE_U128, 'Treasury inflow amount.', []], 
-        [MODULES.treasury, 'Withdraw Flow', 1404, [], ValueType.TYPE_U128, 'Treasury outflow amount.', []], 
-        [MODULES.treasury, 'Flow over a Period of Time', 1405, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, 'The flow amount between certain periods.', ['begin time', 'end time']], 
-        [MODULES.treasury, 'Deposit Flow over a Period of Time', 1406, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, "The inflow amount between certain periods.", ['begin time', 'end time']], 
-        [MODULES.treasury, 'Withdraw Flow over a Period of Time', 1407, [ValueType.TYPE_U64, ValueType.TYPE_U64], ValueType.TYPE_U128, 'The outflow amount between certain periods.', ['begin time', 'end time']], 
+        [MODULES.treasury, 'Inflow Amount', 1403, [], ValueType.TYPE_U128, 'Treasury inflow amount.', []], 
+        [MODULES.treasury, 'Outflow Amount', 1404, [], ValueType.TYPE_U128, 'Treasury outflow amount.', []], 
+        [MODULES.treasury, 'Number of Payment', 1405, [ValueType.TYPE_ADDRESS], ValueType.TYPE_U64, 'The number of flows generated by a payment.', ['payment address']], 
+        [MODULES.treasury, 'Can anyone deposit ', 1406, [], ValueType.TYPE_BOOL, "Whether to allow any address to deposit?", []], 
     ];
 
     static BoolCmd = Guard.QUERIES.filter(q => q[4] === ValueType.TYPE_BOOL);

package/src/index.ts

@@ -14,4 +14,6 @@ export * from './graphql'
 export * from './entity'
 export * from './wowok'
 export * from './resource'
-export * from './treasury'
+export * from './treasury'
+export * from './payment'
+export * from './withholding'

package/src/machine.ts

@@ -1,9 +1,7 @@
 import { Transaction as TransactionBlock, TransactionObjectArgument, type TransactionResult } from '@mysten/sui/transactions';
 import { Protocol, FnCallType, PermissionObject, RepositoryObject,  PassportObject, MachineObject, MachineAddress,  GuardObject, TxbObject} from './protocol';
 import { IsValidInt, Bcs, array_unique, IsValidArray, IsValidAddress, IsValidName, IsValidName_AllowEmpty, 
-    IsValidEndpoint, IsValidDesription,
-    IsValidUintLarge,
-    IsValidU64} from './utils'
+    IsValidEndpoint, IsValidDesription, IsValidU64 } from './utils'
 import { Permission, PermissionIndexType } from './permission';
 import { Errors, ERROR}  from './exception'
 import { ValueType } from './protocol';

package/src/passport.ts

@@ -94,7 +94,7 @@ export class GuardParser {
 
         // console.log(res[0].data?.content);
         let content = res[0].data!.content as any;
-        if (content?.type != protocol.Package() + '::guard::Guard') {
+        if (content?.type != protocol.Package('base') + '::guard::Guard') {
             ERROR(Errors.Fail, 'GuardObject object invalid')
         }
 
@@ -260,7 +260,7 @@ export class GuardParser {
             if (index === -1) ERROR(Errors.Fail, 'Parse_Guard_Helper invalid type: ' + c.type);
 
 
-            if (c.fields.input.type === (protocol.Package() + '::bcs::BCS')) {
+            if (c.fields.input.type === (protocol.Package('base') + '::bcs::BCS')) {
                 const constants = GuardParser.parse_constant(c.fields.constants); // MUST first
                 const inputs = GuardParser.parse_bcs(constants, Uint8Array.from(c.fields.input.fields.bytes));
                 me.guard_list.push({id: c.fields.id.id, input:[...inputs],  constant:[...constants], digest:r.data?.digest??'', version:r.data?.version ?? ''});

package/src/payment.ts

@@ -0,0 +1,63 @@
+import { CoinObject, FnCallType, PaymentAddress, Protocol, TxbObject} from './protocol';
+import { IsValidDesription, IsValidAddress, IsValidArray, } from './utils';
+import { ERROR, Errors } from './exception';
+import { Transaction as TransactionBlock} from '@mysten/sui/transactions';
+
+export interface Payment_Receiver {
+    address: string;
+    coin: CoinObject;
+}
+
+export interface PaymentParam {
+    receiver: Payment_Receiver[];
+    business_index: bigint;
+    business_remark: string;
+    for_object?: string;
+    for_guard?: string;
+}
+
+export const  PAYMENT_MAX_RECEIVER_COUNT = 200;
+export function create_payment(txb:TransactionBlock, pay_token_type:string, param:PaymentParam) : PaymentAddress {
+    if (!pay_token_type) ERROR(Errors.InvalidParam, 'Payment.New.pay_token_type');
+
+    if (param.receiver.length > PAYMENT_MAX_RECEIVER_COUNT)  {
+        ERROR(Errors.InvalidParam, 'Payment.New.param.receiver');
+    }
+
+    if (!IsValidArray(param.receiver, (item:Payment_Receiver) => { return IsValidAddress(item.address) && Protocol.IsValidObjects([item.coin])})) {
+        ERROR(Errors.IsValidArray, 'Payment.New.param.receiver');
+    }
+
+    if (param?.for_object && !IsValidAddress(param.for_object)) {
+        ERROR(Errors.IsValidAddress, 'Payment.New.param.for_object')
+    }
+    if (param?.for_guard && !IsValidAddress(param.for_guard)) {
+        ERROR(Errors.IsValidAddress, 'Payment.New.param.for_guard')
+    }
+    if (param?.business_remark && !IsValidDesription(param?.business_remark)) {
+        ERROR(Errors.IsValidDesription, 'Payment.New.param.business_remark')
+    }
+    
+    let obj = txb.pure.option('address', param.for_object ?  param.for_object : undefined);
+    const clock = txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
+
+    if (param.for_guard) {
+        return txb.moveCall({
+            target:Protocol.Instance().PaymentFn('create_withGuard') as FnCallType,
+            arguments:[txb.pure.vector('address', param.receiver.map((i)=>i.address)), txb.makeMoveVec({elements:param.receiver.map((i)=>i.coin)}), 
+                obj, txb.object(param.for_guard), txb.pure.u64(param.business_index), txb.pure.string(param.business_remark), txb.object(clock)],
+            typeArguments:[pay_token_type],
+        })                
+    } else {
+        return txb.moveCall({
+            target:Protocol.Instance().PaymentFn('new') as FnCallType,
+            arguments:[txb.pure.vector('address', param.receiver.map((i)=>i.address)), txb.makeMoveVec({elements:param.receiver.map((i)=>i.coin)}), 
+                obj, txb.pure.u64(param.business_index), txb.pure.string(param.business_remark), txb.object(clock)],
+            typeArguments:[pay_token_type],
+        })                
+    }
+}
+
+
+
+    

package/src/permission.ts

@@ -1,7 +1,6 @@
 import { FnCallType, TxbObject, PermissionObject, PermissionAddress, GuardObject, Protocol} from './protocol';
-import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, IsValidUintLarge, Bcs, IsValidName} from './utils';
+import { array_unique, IsValidAddress, IsValidArray,  IsValidDesription, Bcs, IsValidName, IsValidU64} from './utils';
 import { ERROR, Errors } from './exception';
-import { ValueType } from './protocol';
 import { BCS } from '@mysten/bcs';
 import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
@@ -80,10 +79,11 @@ export enum PermissionIndex {
     progress_parent = 655,
 
     treasury = 700,
-    treasury_deposit = 701,
-    treasury_withdraw = 702,
-    treasury_free_deposit_set = 703,
+    treasury_receive = 701,
+    treasury_deposit = 702,
+    treasury_withdraw = 703,
     treasury_descritption = 704, 
+    treasury_free_deposit_set = 705,
     user_defined_start = 1000,
 }
 
@@ -184,6 +184,7 @@ export const PermissionInfo : PermissionInfoType[] = [
     
     {index:PermissionIndex.treasury, name: 'Treasury', description:'Launch new Treasury', module: 'treasury'},
     {index:PermissionIndex.treasury_deposit, name: 'Deposit', description:'Deposit coins', module: 'treasury'},
+    {index:PermissionIndex.treasury_receive, name: 'Receive', description:'Receive coins from some address sent', module: 'treasury'},
     {index:PermissionIndex.treasury_withdraw, name: 'Withdraw', description:'Withdraw coins', module: 'treasury'},
     {index:PermissionIndex.treasury_free_deposit_set, name: 'Be Free Deposit', description:'Set whether deposits can be made without permission', module: 'treasury'},
     {index:PermissionIndex.treasury_descritption, name: 'Description', description:'Set Treasury description', module: 'treasury'},
@@ -565,7 +566,7 @@ export class  Permission {
     static BUSINESS_PERMISSIONS_START = PermissionIndex.user_defined_start;
 
     static IsValidUserDefinedIndex = (index:number)  => { 
-        return index >= Permission.BUSINESS_PERMISSIONS_START && IsValidUintLarge(index)
+        return index >= Permission.BUSINESS_PERMISSIONS_START && IsValidU64(index)
     }
     
     static IsValidPermissionIndex = (index:PermissionIndexType) : boolean  => {

package/src/progress.ts

@@ -78,7 +78,6 @@ export class Progress {
     }
 
     launch() : ProgressAddress {
-        
         return this.txb.moveCall({
             target:Protocol.Instance().ProgressFn('create') as FnCallType,
             arguments: [Protocol.TXB_OBJECT(this.txb, this.object)],

package/src/protocol.ts

@@ -3,7 +3,7 @@ import { SuiClient, SuiObjectResponse, SuiObjectDataOptions, SuiTransactionBlock
 import { Ed25519Keypair } from '@mysten/sui/keypairs/ed25519';
 import { toHEX, fromHEX, BcsReader } from '@mysten/bcs';
 import { Transaction as TransactionBlock, Inputs, TransactionResult, TransactionArgument } from '@mysten/sui/transactions';
-import { capitalize, IsValidAddress, IsValidArray, IsValidU128, IsValidU64, IsValidU8, IsValidUintLarge } from './utils'
+import { capitalize, IsValidAddress, IsValidArray, IsValidU128, IsValidU256, IsValidU64, IsValidU8 } from './utils'
 import { GuardConstant } from './guard';
 import { isValidSuiAddress, isValidSuiObjectId } from '@mysten/sui/utils'
 
@@ -11,7 +11,6 @@ export enum MODULES {
     machine = 'machine',
     node = 'node',
     progress = 'progress',
-    community = 'community',
     repository = 'repository',
     permission = 'permission',
     passport = 'passport',
@@ -56,6 +55,11 @@ export type ResourceObject = TransactionResult | string | TransactionArgument;
 export type ResourceAddress = TransactionResult;
 export type EntityObject = TransactionResult | string | TransactionArgument;
 export type EntityAddress = TransactionResult;
+export type TreasuryAddress = TransactionResult;
+export type PaymentObject = TransactionResult | string | TransactionArgument;
+export type PaymentAddress = TransactionResult;
+export type ReceivedObject = TransactionResult | string | TransactionArgument;
+export type CoinWrapperObject = TransactionResult;
 
 export type TxbObject = string | TransactionResult | TransactionArgument | GuardObject |  RepositoryObject | PermissionObject | MachineObject | PassportObject |
     DemandObject | ServiceObject | RewardObject | OrderObject | DiscountObject | VoteObject | DemandObject | ResourceObject | EntityObject;
@@ -190,7 +194,7 @@ export const SER_VALUE: ValueTypeString[] = [
     {type: ValueType.TYPE_VEC_STRING, name: '[string]', description:'ascii string array. eg:["abc", "hi"]'},
     {type: ValueType.TYPE_STRING, name: 'string', description:'eg:"wowok"', },
     {type: ValueType.TYPE_OPTION_STRING, name: 'option', description:'option of string. eg:none or string value'},
-    {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233', validator:IsValidUintLarge},
+    {type: ValueType.TYPE_U256, name: 'number', description:'unsigned-256 number. eg:12345678901233', validator:IsValidU256},
 ]
 
 //export type ConstantType = ValueType | ContextType.TYPE_WITNESS_ID;
@@ -204,20 +208,22 @@ export enum ENTRYPOINT {
 }
 /*
 const TESTNET = {
-    package: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
+    wowok: "0xbd3d0929072f7647e521bf72851ccdc7e2169052b22bfdc5b49439c48cfb119a",
     wowok_object: '0xb0a521a287e9d5e08932b3984dbe6ce159e836179c41bd08c556ef77ecdb7439',
     entity_object: '0x16aab98920e7341d1dc19631031253234b2b71fc2ab8c32d65ee3ded8072acef',
     treasury_cap:'0xb75a2ca2f651755c134ad521175f33f9e3f9008ad44340f76b3229e1f30cfdff',
 }
 */
 const TESTNET = {
-    package: "0xf108d64c8143ec040da0d5538e834a67f0a9c661f92011195b60f51b3bc33a46",
-    wowok_object: '0xc4fc2a42a5fbcfc68b3d8ac079e4d5a07f637c541e0183446a9da655965cda5e',
-    entity_object: '0x8bbab9023092dc89c3c60c766b204c0dfbe3da46a2de486d8ab92ba91a4c905f',
-    treasury_cap:'0x07e7b3c355b63bade82c1e0e2653e655a1b20da6cc531db5707ad1292fd418e4',
+    wowok: "0xb82ef16ea48fb4f732310c3a0c86c34d0b8711f4dac1c4ca693005345047bfa4",
+    base: '0x74fb58a0b148f19852a721293a797fdeb59dec5da71ca31838fc810af2d32fdd',
+    wowok_object: '0x41c93c2903227632a33394d37fd3b7f62a33bc72b16a7f9aafc8161b78b232be',
+    entity_object: '0x0b34c975a4b179755dabdec5c50505bd21c0439c463d171a54fa44f215e3bb57',
+    treasury_cap:'0xacb8b1d380d4f75a802dd7412142290bebd7f6266785690de2daf68f6a7ba9ce',
 }
 const MAINNET = {
-    package: "",
+    wowok: "",
+    base:"",
     wowok_object: '',
     entity_object: '',
     treasury_cap:'',
@@ -231,7 +237,7 @@ export interface CoinTypeInfo {
 }
 export class Protocol {
     protected network = '';
-    protected package = '';
+    protected package = new Map<string, string>();
     protected signer = '';
     protected wowok_object = '';
     protected entity_object = '';
@@ -262,14 +268,16 @@ export class Protocol {
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = TESTNET.package;
+                this.package.set('wowok', TESTNET.wowok);
+                this.package.set('base', TESTNET.base);
                 this.wowok_object = TESTNET.wowok_object;
                 this.entity_object= TESTNET.entity_object;
                 this.treasury_cap = TESTNET.treasury_cap;
                 this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
             case ENTRYPOINT.mainnet:
-                this.package = MAINNET.package;
+                this.package.set('wowok', MAINNET.wowok);
+                this.package.set('base', MAINNET.base);
                 this.wowok_object = MAINNET.wowok_object;
                 this.entity_object= MAINNET.entity_object;
                 this.treasury_cap = MAINNET.treasury_cap;
@@ -277,7 +285,10 @@ export class Protocol {
                 break;
         };
     }
-    Package(): string { return this.package }
+    Package(type:string): string { 
+        return this.package.get(type) ?? ''
+    }
+
     WowokObject(): string { return this.wowok_object }
     EntityObject(): string { return this.entity_object }
     TreasuryCap() : string { return this.treasury_cap }
@@ -296,22 +307,23 @@ export class Protocol {
         }; return "";
     };
     
-    MachineFn = (fn:any) => { return `${this.package}::${MODULES.machine}::${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}`};
-    PermissionFn = (fn: any) => { return `${this.package}::${MODULES.permission}::${fn}`};
-    PassportFn = (fn:any) => { return `${this.package}::${MODULES.passport}::${fn}`};
-    GuardFn = (fn: any) => { return `${this.package}::${MODULES.guard}::${fn}`};
-    VoteFn = (fn:any) => { return `${this.package}::${MODULES.vote}::${fn}`};
-    DemandFn = (fn: any) => { return `${this.package}::${MODULES.demand}::${fn}`};
-    OrderFn = (fn:any) => { return `${this.package}::${MODULES.order}::${fn}`};
-    RewardFn = (fn: any) => { return `${this.package}::${MODULES.reward}::${fn}`};
-    ServiceFn = (fn: any) => { return `${this.package}::${MODULES.service}::${fn}`};
-    ResourceFn = (fn: any) => { return `${this.package}::${MODULES.resource}::${fn}`};
-    EntityFn = (fn: any) => { return `${this.package}::${MODULES.entity}::${fn}`};
-    WowokFn = (fn: any) => { return `${this.package}::${MODULES.wowok}::${fn}`};
-    TreasuryFn = (fn: any) => { return `${this.package}::${MODULES.treasury}::${fn}`};
+    MachineFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.machine}::${fn}`};
+    ProgressFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.progress}::${fn}`};
+    RepositoryFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.repository}::${fn}`};
+    PermissionFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.permission}::${fn}`};
+    PassportFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.passport}::${fn}`};
+    GuardFn = (fn: any) => { return `${this.package.get('base')}::${MODULES.guard}::${fn}`};
+    VoteFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.vote}::${fn}`};
+    DemandFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.demand}::${fn}`};
+    OrderFn = (fn:any) => { return `${this.package.get('wowok')}::${MODULES.order}::${fn}`};
+    RewardFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.reward}::${fn}`};
+    ServiceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.service}::${fn}`};
+    ResourceFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.resource}::${fn}`};
+    EntityFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.entity}::${fn}`};
+    WowokFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.wowok}::${fn}`};
+    TreasuryFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.treasury}::${fn}`};
+    PaymentFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.payment}::${fn}`};
+    WithholdingFn = (fn: any) => { return `${this.package.get('wowok')}::${MODULES.withholding}::${fn}`};
     
     Query = async (objects: Query_Param[], options:SuiObjectDataOptions={showContent:true}) : Promise<SuiObjectResponse[]> => {
         const client =  new SuiClient({ url: this.NetworkUrl() });  
@@ -342,7 +354,6 @@ export class Protocol {
 
         const privkey = fromHEX(priv_key);
         const keypair = Ed25519Keypair.fromSecretKey(privkey);
-
         const response = await client.signAndExecuteTransaction({
             transaction: this.CurrentSession(), 
             signer: keypair,
@@ -356,8 +367,8 @@ export class Protocol {
     static SUI_TOKEN_TYPE = '0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI'; // TOKEN_TYPE
     // used in demand, reward, ...
     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>'}
+    WOWOK_TOKEN_TYPE = () => { return this.package.get('wowok') + '::wowok::WOWOK' }
+    WOWOK_COIN_TYPE = () => {  return '0x2::coin::Coin<' + this.package.get('wowok') + '::wowok::WOWOK>'}
     COINS_TYPE = () => { 
         switch(this.network) {
             case ENTRYPOINT.testnet:
@@ -392,13 +403,13 @@ export class Protocol {
     CoinTypes_Testnet:CoinTypeInfo[] = [
         {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
         {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
-        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+        {symbol:'WOW', type:TESTNET.wowok + '::wowok::WOWOK', decimals:9},
     ];
 
     CoinTypes_Mainnet:CoinTypeInfo[] = [
         {symbol:'SUI', type:'0x0000000000000000000000000000000000000000000000000000000000000002::sui::SUI', decimals:9, alias:true},
         {symbol:'SUI', type:'0x2::sui::SUI', decimals:9, },
-        {symbol:'WOW', type:TESTNET.package + '::wowok::WOWOK', decimals:9},
+        {symbol:'WOW', type:TESTNET.wowok + '::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},
@@ -438,13 +449,20 @@ export class Protocol {
         })
     }  
     WOWOK_OBJECTS_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
-        { let i = this.package + '::' + key + '::';  return i + capitalize(key); })
+        { let i = this.package.get('wowok') + '::' + key + '::';  return i + capitalize(key); })
     WOWOK_OBJECTS_PREFIX_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => 
-        { return this.package + '::' + key + '::'; })
+        { return this.package.get('wowok') + '::' + key + '::'; })
+    private hasPackage(pack:string) : boolean {
+        for (let value of this.package.values()) {
+            if (value === pack) {
+                return true;
+            }
+        } return false;
+    }
     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) {
+        if (i > 0 && this.hasPackage(type_repr.slice(0, i))) {
             i = type_repr.indexOf('<');
             if (i > 0) {
                 type_repr = type_repr.slice(0, i);
@@ -457,6 +475,22 @@ export class Protocol {
         }
         return ''
     }
+    module_object_name_from_type_repr = (type_repr:string) : string => {
+        if (!type_repr) return ''
+        let i = type_repr.indexOf('::');
+        if (i > 0 && this.hasPackage(type_repr.slice(0, i))) {
+            i = type_repr.indexOf('<');
+            if (i > 0) {
+                type_repr = type_repr.slice(0, i);
+            }
+            
+            let n = type_repr.indexOf('::');
+            if (n > 0) {
+                return type_repr.slice(n+2);
+            }
+        }
+        return ''
+    }
 }
 
 export class RpcResultParser {
@@ -471,8 +505,7 @@ export class RpcResultParser {
         if (response?.objectChanges) {
             response.objectChanges.forEach((change) => {
                 RpcResultParser.Object_Type_Extra().forEach((name) => {
-                    let type = protocol.Package() + '::' + name;
-                    if (change.type == 'created' && change.objectType.includes(type)) {
+                    if (change.type == 'created' && protocol.module_object_name_from_type_repr(change.objectType)===name)  {
                         if (ret.has(name)) {
                             ret.get(name)?.push(change.objectId);
                         } else {

package/src/repository.ts

@@ -2,7 +2,7 @@ import { Protocol, FnCallType, ValueType, RepositoryValueType, RepositoryAddress
 import { PermissionIndexType, Permission } from './permission'
 import { Bcs, array_unique, IsValidDesription, IsValidAddress, IsValidArray, IsValidName,  ValueTypeConvert} from './utils';
 import { ERROR, Errors } from './exception';
-import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, stringToUint8Array } from './utils';
+import { MAX_U8, MAX_U128, MAX_U256, MAX_U64, parseObjectType } from './utils';
 import { type TransactionResult, Transaction as TransactionBlock } from '@mysten/sui/transactions';
 
 export enum Repository_Policy_Mode {
@@ -394,16 +394,8 @@ export class Repository {
     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 parseObjectType = (chain_type?:string | null) : string =>  {
+        return parseObjectType(chain_type, 'repository::Repository<');
     }
 
     static rpc_de_data(fields:any) : RepData [] {

package/src/resource.ts

@@ -21,6 +21,8 @@ export class Resource {
     static LikeName = "like";
     static DislikeName = "dislike";
     static FavorName = "favor";
+    static LaunchName = 'launch';
+    static OrderName = 'order';
 
     protected object:TxbObject;
     protected txb;
@@ -55,14 +57,14 @@ export class Resource {
         });
     }
 
-    add2(object:string, name:string[])  {
-        if (!IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
+    add2(object:TxbObject, name:string[])  {
+        if (typeof(object) === 'string' && !IsValidAddress(object)) ERROR(Errors.IsValidAddress, 'add2');
         if (!IsValidArray(name, IsValidName)) ERROR(Errors.IsValidArray, 'add2');
         if (!name) return 
 
         this.txb.moveCall({
             target:Protocol.Instance().ResourceFn('add2')  as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.address(object), 
+            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), typeof(object) === 'string' ? this.txb.pure.address(object) : object, 
                 this.txb.pure.vector('string', name)]
         });
     }