wowok 1.0.3 → 1.0.5

package/src/protocol.ts

@@ -2,25 +2,39 @@ import { SuiClient, SuiObjectResponse, SuiObjectDataOptions, SuiTransactionBlock
     SuiTransactionBlockResponse, SuiObjectChange } from '@mysten/sui.js/client';
 import { Ed25519Keypair } from '@mysten/sui.js/keypairs/ed25519';
 import { BCS, getSuiMoveConfig, toHEX, fromHEX, BcsReader } from '@mysten/bcs';
-import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
+import { TransactionBlock, Inputs, type TransactionResult, type TransactionArgument } from '@mysten/sui.js/transactions';
 import { capitalize } from './util'
 
-export type GuardObject = TransactionResult;
-export type GuardAddress = TransactionResult;
-
 export const MAX_DESCRIPTION_LENGTH = 1024;
 export const MAX_NAME_LENGTH = 64;
 export const MAX_ENDPOINT_LENGTH = 1024;
+export const OptionNone = (txb:TransactionBlock) : TransactionArgument => { return txb.pure([], BCS.U8) };
 
-export function description_data(description:string) : string {
-    return description.substring(0, MAX_DESCRIPTION_LENGTH);
-}
-export function endpoint_data(endpoint:string) : string {
-    return endpoint.substring(0, MAX_ENDPOINT_LENGTH);
+export const IsValidDesription = (description:string) : boolean => { return description.length <= MAX_DESCRIPTION_LENGTH }
+export const IsValidName = (name:string) : boolean => { return name.length <= MAX_NAME_LENGTH && name.length != 0 }
+export const IsValidName_AllowEmpty = (name:string) : boolean => { return name.length <= MAX_NAME_LENGTH }
+export const IsValidEndpoint = (endpoint:string) : boolean => { return endpoint.length <= MAX_ENDPOINT_LENGTH }
+export const IsValidAddress = (address:string) : boolean => { return address.length != 0 }
+export const IsValidArgType = (argType: string) : boolean => { return argType.length != 0 }
+export const IsValidUint = (value: number) : boolean => { return Number.isSafeInteger(value) && value != 0 }
+export const IsValidInt = (value: number) : boolean => { return Number.isSafeInteger(value) }
+export const IsValidPercent = (value: number) : boolean => { return Number.isSafeInteger(value) && value > 0 && value <= 100 }
+export const IsValidArray = (arr: any[], validFunc:any) : boolean => {
+    let bValid = true;
+    arr.forEach((v) => {
+        if (!validFunc(v)) {
+            bValid = false; 
+        }
+    })
+    return bValid;
 }
-export function name_data(name:string) : string {
-    return name.substring(0, MAX_NAME_LENGTH);
+export const IsValidObjects = (arr:TxbObject[]) : boolean => { 
+    return IsValidArray(arr, (v:TxbObject)=>{ 
+        if (!v)  return false
+        return true
+    })
 }
+
 export enum MODULES {
     machine = 'machine',
     node = 'node',
@@ -38,7 +52,32 @@ export enum MODULES {
     wowok = 'wowok',
 }
 
-export type TxbObject = string | TransactionResult;
+export type PermissionAddress = TransactionResult;
+export type PermissionObject = TransactionResult | string;
+export type RepositoryAddress = TransactionResult;
+export type RepositoryObject = TransactionResult | string;
+export type GuardAddress = TransactionResult;
+export type GuardObject = TransactionResult | string;
+export type MachineAddress = TransactionResult;
+export type MachineObject = TransactionResult | string;
+export type PassportObject = TransactionResult;
+export type DemandAddress = TransactionResult;
+export type DemandObject = TransactionResult | string;
+export type ServiceObject = TransactionResult  | string;
+export type ServiceAddress = TransactionResult;
+export type ProgressObject = TransactionResult | string;
+export type ProgressAddress = TransactionResult;
+export type RewardObject = TransactionResult | string;
+export type RewardAddress = TransactionResult;
+export type OrderObject = TransactionResult | string;
+export type OrderAddress = TransactionResult;
+export type DiscountObject = TransactionResult | string;
+export type CoinObject = TransactionResult | string;
+export type VoteObject = TransactionResult | string;
+export type VoteAddress = TransactionResult;
+
+export type TxbObject = string | TransactionResult | GuardObject |  RepositoryObject | PermissionObject | MachineObject | PassportObject |
+    DemandObject | ServiceObject | RewardObject | OrderObject | DiscountObject | VoteObject | DemandObject;
 export function TXB_OBJECT(txb:TransactionBlock, arg:TxbObject) : TransactionResult {
     if (typeof arg == 'string') return txb.object(arg) as TransactionResult;
     return arg;
@@ -53,20 +92,7 @@ export const CLOCK_OBJECT = Inputs.SharedObjectRef({
     initialSharedVersion: 1,
 });
 
-export enum Data_Type {
-    TYPE_DYNAMIC_QUERY = 1,
-    TYPE_LOGIC_OPERATOR_U128_GREATER = 11,
-    TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL = 12,
-    TYPE_LOGIC_OPERATOR_U128_LESSER = 13,
-    TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL = 14,
-    TYPE_LOGIC_OPERATOR_U128_EQUAL = 15,
-    TYPE_LOGIC_OPERATOR_EQUAL = 16, // TYPE&DATA(vector<u8>) MUST BE EQUAL
-    TYPE_LOGIC_OPERATOR_HAS_SUBSTRING = 17, // SUBSTRING
-    TYPE_LOGIC_ALWAYS_TRUE = 18, // aways true
-    // TYPE_LOGIC_OPERATOR_VECU8_CONTAINS = 18, // SUB VEC<U8>
-    TYPE_CONTEXT_SIGNER  = 60,
-    TYPE_CONTEXT_CURRENT_PROGRESS = 61,
-    TYPE_CONTEXT_CURRENT_CLOCK = 62,
+export enum ValueType {
     TYPE_STATIC_bool = 100,
     TYPE_STATIC_address = 101,
     TYPE_STATIC_u64 = 102,
@@ -83,10 +109,28 @@ export enum Data_Type {
     TYPE_STATIC_option_u8 = 113,
     TYPE_STATIC_option_u64 = 114,
     TYPE_STATIC_option_u128 = 115,
-    TYPE_STATIC_by_value_specified = 126,
-    TYPE_STATIC_error = 127,
 }
 
+export enum OperatorType {
+    TYPE_DYNAMIC_QUERY = 1, // query wowok object
+    TYPE_LOGIC_OPERATOR_U128_GREATER = 11,
+    TYPE_LOGIC_OPERATOR_U128_GREATER_EQUAL = 12,
+    TYPE_LOGIC_OPERATOR_U128_LESSER = 13,
+    TYPE_LOGIC_OPERATOR_U128_LESSER_EQUAL = 14,
+    TYPE_LOGIC_OPERATOR_U128_EQUAL = 15,
+    TYPE_LOGIC_OPERATOR_EQUAL = 16, // TYPE&DATA(vector<u8>) MUST BE EQUAL
+    TYPE_LOGIC_OPERATOR_HAS_SUBSTRING = 17, // SUBSTRING
+    TYPE_LOGIC_ALWAYS_TRUE = 18, // aways true
+}
+
+export enum ContextType {
+    TYPE_CONTEXT_SIGNER  = 60,
+    TYPE_CONTEXT_CURRENT_PROGRESS = 61,
+    TYPE_CONTEXT_CURRENT_CLOCK = 62,
+}
+
+export type Data_Type = ValueType | OperatorType | ContextType;
+
 export enum ENTRYPOINT {
     mainnet = 'mainnet',
     testnet = 'testnet',
@@ -99,20 +143,25 @@ export class Protocol {
     protected package = '';
     protected signer = '';
     protected everyone_guard = '';
+    protected graphql = '';
 
     constructor(network:ENTRYPOINT=ENTRYPOINT.localnet, signer="0xe386bb9e01b3528b75f3751ad8a1e418b207ad979fea364087deef5250a73d3f") {
-        this.network = network;
         this.signer = signer;
+        this.UseNetwork(network);
+    }
+    UseNetwork(network:ENTRYPOINT=ENTRYPOINT.localnet) {
+        this.network = network;
         switch(network) {
             case ENTRYPOINT.localnet:
-                this.package = "0x74df733df2395d0c3a34c6d086d2e1f130603b8aa16962e53781cb0fa9c6958c";
-                this.everyone_guard = "0xb1a2e3d0cf13c3fcb491f126af8422f7d098147659d8a58a52511cfbb783a6e8";
+                this.package = "0xe9721254e97dd074e06c5efe5c57be169b64b39ae48939d89c00bf2f62b19e10";
+                this.everyone_guard = "0xb2a3fe7881cb883743c4e962b7e3c7716a1cd47a67adad01dc79795def4f769d";
                 break;
             case ENTRYPOINT.devnet:
                 break;
             case ENTRYPOINT.testnet:
-                this.package = "0x038b0be329e4fd227d846b850aeb1822f9629c62c14d85ffcd22d856c843923f";
-                this.everyone_guard = "0xdfe42468bfc7d7988fa1707978ef9376178dcefbe938d140a1bfd97abe755998";
+                this.package = "0x877375bc3bde063e4b95f428df218af7faaeef431993f4a68f2dfa5ceb8acb2e";
+                this.everyone_guard = "0x78a41fcc4f566360839613f6b917fb101ae015e56b43143f496f265b6422fddc";
+                this.graphql = 'https://sui-testnet.mystenlabs.com/graphql';
                 break;
             case ENTRYPOINT.mainnet:
                 break;
@@ -120,6 +169,8 @@ export class Protocol {
     }
     Package(): string { return this.package }
     EveryoneGuard(): string { return this.everyone_guard }
+    GraphqlUrl() : string { return this.graphql }
+    
     NetworkUrl() : string { 
         switch(this.network) {
             case ENTRYPOINT.localnet:
@@ -132,6 +183,7 @@ export class Protocol {
                 return "https://fullnode.mainnet.sui.io:443";
         }; return "";
     };
+    
     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}`};
@@ -160,11 +212,12 @@ export class Protocol {
         }   
         return res;
     } 
-    Sign_Excute = async (exes: (txb:TransactionBlock, param:any) => void, priv_key:string, param?:any, options:SuiTransactionBlockResponseOptions={showObjectChanges:true}) : Promise<SuiTransactionBlockResponse> => {
+    Sign_Excute = async (exes: ((txb:TransactionBlock, param:any) => void)[], priv_key:string, param?:any, options:SuiTransactionBlockResponseOptions={showObjectChanges:true}) : Promise<SuiTransactionBlockResponse> => {
         const client =  new SuiClient({ url: PROTOCOL.NetworkUrl() });  
         const txb = new TransactionBlock();
-    
-        exes(txb, param);
+
+        exes.forEach((e) => { e(txb, param) });
+
         const privkey = fromHEX(priv_key);
         const keypair = Ed25519Keypair.fromSecretKey(privkey);
     
@@ -182,8 +235,9 @@ export type Query_Param = {
     callback: (response:SuiObjectResponse, param:Query_Param, option:SuiObjectDataOptions)=>void;
     data?: any; // response data filted by callback
 };
-
-
 export const PROTOCOL = new Protocol();
-export const OBJECTS_TYPE_PREFIX = (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { return PROTOCOL.Package() + '::' + key + '::'; })
-export const OBJECTS_TYPE = (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { let i = PROTOCOL.Package() + '::' + key + '::'; return i + capitalize(key); })
+export const SUI_TYPE = '0x2::coin::Coin<0x2::sui::SUI>';
+export const WOWOK_TYPE = () => {'0x2::coin::Coin<' + PROTOCOL.Package() + '::wowok::WOWOK'};
+
+export const OBJECTS_TYPE_PREFIX = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { return PROTOCOL.Package() + '::' + key + '::'; })
+export const OBJECTS_TYPE = () => (Object.keys(MODULES) as Array<keyof typeof MODULES>).map((key) => { let i = PROTOCOL.Package() + '::' + key + '::'; return i + capitalize(key); })

package/src/repository.ts

@@ -1,213 +1,286 @@
 import { TransactionBlock, Inputs, type TransactionResult } from '@mysten/sui.js/transactions';
 import { BCS } from '@mysten/bcs';
-import { name_data, FnCallType, Data_Type, PROTOCOL, description_data} from './protocol';
-import { PassportObject, verify,  } from './passport'
-import { PermissionIndex, PermissionObject } from './permission'
+import { FnCallType, PROTOCOL, ValueType, IsValidDesription, IsValidAddress, IsValidArray, OptionNone, 
+    RepositoryObject, RepositoryAddress, PermissionObject, TXB_OBJECT, PassportObject, IsValidObjects,
+    IsValidInt} from './protocol';
+import { IsValidPermissionIndex, PermissionIndexType  } from './permission'
+import { BCS_CONVERT, array_unique } from './util';
 
-export const MAX_POLICY_COUNT = 128;
+export const MAX_POLICY_COUNT = 1000;
+export const MAX_KEY_LENGTH = 128;
+export const MAX_VALUE_LENGTH = 204800;
+
+export const IsValidKey = (key:string) : boolean => {
+    return key.length <= MAX_KEY_LENGTH && key.length != 0;
+}
+export const IsValidValue = (value:Uint8Array) : boolean => {
+    return value.length < MAX_VALUE_LENGTH;
+}
 
 export enum Repository_Policy_Mode {
     POLICY_MODE_FREE = 0,
     POLICY_MODE_STRICT = 1,
 }
 export type Repository_Policy = {
-    name:string;
+    key:string;
     description: string;
-    permission?: PermissionIndex;
-    value_type: Data_Type;
+    value_type: ValueType;
+    permission?: PermissionIndexType; // PermissionIndex like, must be geater than 10000
 }
 export type Repository_Policy_Data = {
-    name: string;
+    key: string;
     data: Repository_Value[];
-    value_type?: Data_Type;
+    value_type?: ValueType;
 }
 export type Repository_Value = {
     address: string; // UID: address or objectid
-    value: Uint8Array;
+    bcsBytes: Uint8Array;
 }
 
-export type RepositoryAddress = TransactionResult;
-export type RepositoryObject = TransactionResult;
+export function repository(txb:TransactionBlock, permission:PermissionObject, description:string, 
+    policy_mode: Repository_Policy_Mode, passport?:PassportObject) : RepositoryObject | boolean {
+    if (!IsValidObjects([permission])) return false;
+    if (!IsValidDesription(description)) return false;
 
-export function repository(txb:TransactionBlock, permission:PermissionObject, 
-    description:string, policy_mode: Repository_Policy_Mode, passport?:PassportObject) : RepositoryObject {
     if (passport) {
         return txb.moveCall({
             target:PROTOCOL.RepositoryFn('new_with_passport') as FnCallType,
-            arguments:[passport, txb.pure(description_data(description)), txb.pure(policy_mode, BCS.U8), permission],
+            arguments:[passport, txb.pure(description), txb.pure(policy_mode, BCS.U8), TXB_OBJECT(txb, permission)],
         })
     } else {
         return txb.moveCall({
             target:PROTOCOL.RepositoryFn('new') as FnCallType,
-            arguments:[txb.pure(description_data(description)), txb.pure(policy_mode, BCS.U8), permission],
+            arguments:[txb.pure(description), txb.pure(policy_mode, BCS.U8), TXB_OBJECT(txb, permission)],
         })
     }
+    return true;
 }
 
-export function launch(txb:TransactionBlock, repository:RepositoryObject) : RepositoryAddress {
+export function launch(txb:TransactionBlock, repository:RepositoryObject) : RepositoryAddress | boolean {
+    if (!IsValidObjects([repository])) return false;
     return txb.moveCall({
         target:PROTOCOL.RepositoryFn('create') as FnCallType,
-        arguments:[repository],
+        arguments:[TXB_OBJECT(txb, repository)],
     })    
 }
-export function destroy(txb:TransactionBlock, repository:RepositoryObject) {
-    return txb.moveCall({
+export function destroy(txb:TransactionBlock, repository:RepositoryObject) : boolean {
+    if (!IsValidObjects([repository])) return false;
+    txb.moveCall({
         target:PROTOCOL.RepositoryFn('destroy') as FnCallType,
-        arguments: [repository],
+        arguments: [TXB_OBJECT(txb, repository)],
     })   
+    return true
 }
-export function add_data(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, data:Repository_Policy_Data) {
+
+export function add_data(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, data:Repository_Policy_Data) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!IsValidKey(data.key)) return false; 
+    let bValid = true;
+    data.data.forEach((value) => {
+        if (!IsValidAddress(value.address)) bValid = false;
+        if (!IsValidValue(value.bcsBytes)) bValid = false; 
+    });
+    if (!bValid) return false;
+
     if (data?.value_type) {
         data.data.forEach((d) => txb.moveCall({
             target:PROTOCOL.RepositoryFn('add') as FnCallType,
-            arguments:[repository, 
+            arguments:[TXB_OBJECT(txb, repository), 
                 txb.pure(d.address, BCS.ADDRESS),
-                txb.pure(name_data(data.name)), 
+                txb.pure(data.key), 
                 txb.pure(data.value_type, BCS.U8),
-                txb.pure(d.value, 'vector<u8>'),
-                permission,
+                txb.pure([...d.bcsBytes], 'vector<u8>'),
+                TXB_OBJECT(txb, permission),
             ],
-        }))            
+        }))       
     } else {
         data.data.forEach((d) => txb.moveCall({
             target:PROTOCOL.RepositoryFn('add_typed_data') as FnCallType,
-            arguments:[repository, 
+            arguments:[TXB_OBJECT(txb, repository), 
                 txb.pure(d.address, BCS.ADDRESS),
-                txb.pure(name_data(data.name)), 
-                txb.pure(d.value, 'vector<u8>'),
-                permission,
+                txb.pure(data.key), 
+                txb.pure([...d.bcsBytes], 'vector<u8>'),
+                TXB_OBJECT(txb, permission),
             ],
         }))   
     }
+    return true;
 }
 
-export function remove(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, address:string, name:string) {
+export function remove(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, address:string, key:string) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!IsValidKey(key) || !IsValidAddress(address)) return false;
+
     txb.moveCall({
         target:PROTOCOL.RepositoryFn('remove') as FnCallType,
-        arguments:[repository, 
+        arguments:[TXB_OBJECT(txb, repository), 
             txb.pure(address, BCS.ADDRESS),
-            txb.pure(name_data(name)), 
-            permission,
+            txb.pure(key), 
+            TXB_OBJECT(txb, permission),
         ],
-    })    
+    })  
+    return true  
 }
 // add or modify the old 
-export function repository_add_policies(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, policies:Repository_Policy[], passport?:PassportObject) {
+export function repository_add_policies(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, 
+    policies:Repository_Policy[], passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!policies) return false;
+
+    let bValid = true;
+    policies.forEach((p) => {
+        if (!IsValidDesription(p.description) || !IsValidKey(p.key)) {
+            bValid = false
+        }
+    });
+    if (!bValid) return false;
+
     policies.forEach((policy) => {
-        let permission_index = policy?.permission ? txb.pure(policy.permission, BCS.U64) : txb.pure([0], BCS.U8);
+        let permission_index = policy?.permission ? txb.pure(BCS_CONVERT.ser_option_u64(policy.permission)) : txb.pure([0], BCS.U8);
         if (passport) {
             txb.moveCall({
                 target:PROTOCOL.RepositoryFn('policy_add_with_passport') as FnCallType,
-                arguments:[passport, repository, 
-                    txb.pure(name_data(policy.name)), 
-                    txb.pure(description_data(policy.description)),
-                    permission_index, txb.pure(policy.value_type, BCS.U8)]
+                arguments:[passport, TXB_OBJECT(txb, repository), 
+                    txb.pure(policy.key), 
+                    txb.pure(policy.description),
+                    permission_index, txb.pure(policy.value_type, BCS.U8),
+                    TXB_OBJECT(txb, permission)]
             })              
         } else {
             txb.moveCall({
                 target:PROTOCOL.RepositoryFn('policy_add') as FnCallType,
-                arguments:[repository, 
-                    txb.pure(name_data(policy.name)), 
-                    txb.pure(description_data(policy.description)),
-                    permission_index, txb.pure(policy.value_type, BCS.U8)]
+                arguments:[TXB_OBJECT(txb, repository), 
+                    txb.pure(policy.key), 
+                    txb.pure(policy.description),
+                    permission_index, txb.pure(policy.value_type, BCS.U8),
+                    TXB_OBJECT(txb, permission)]
             })  
         }
     });    
+    return true;
 }
 
-export function repository_remove_policies(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, policy_names:string[], removeall?:boolean, passport?:PassportObject) {
+export function repository_remove_policies(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, 
+    policy_keys:string[], removeall?:boolean, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!removeall && !policy_keys) return false;
+    if (policy_keys && !IsValidArray(policy_keys, IsValidKey)) return false;
+
     if (passport) {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.RepositoryFn('policy_remove_all_with_passport') as FnCallType,
-                arguments:[passport, repository, permission]
+                arguments:[passport, TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)]
             })          
         } else {
-            policy_names.forEach((name) => {
-                txb.moveCall({
-                    target:PROTOCOL.RepositoryFn('policy_remove_with_passport') as FnCallType,
-                    arguments:[passport, repository, txb.pure(name_data(name)), permission]
-                })                
-            })
+            txb.moveCall({
+                target:PROTOCOL.RepositoryFn('policy_remove_with_passport') as FnCallType,
+                arguments:[passport, TXB_OBJECT(txb, repository), txb.pure(BCS_CONVERT.ser_vector_string(array_unique(policy_keys))), TXB_OBJECT(txb, permission)]
+            })                
         }
     } else {
         if (removeall) {
             txb.moveCall({
                 target:PROTOCOL.RepositoryFn('policy_remove_all') as FnCallType,
-                arguments:[repository, permission]
+                arguments:[TXB_OBJECT(txb, repository), TXB_OBJECT(txb, permission)]
             })          
         } else {
-            policy_names.forEach((name) => {
-                txb.moveCall({
-                    target:PROTOCOL.RepositoryFn('policy_remove') as FnCallType,
-                    arguments:[repository, txb.pure(name_data(name)), permission]
-                })                
-            })
+            txb.moveCall({
+                target:PROTOCOL.RepositoryFn('policy_remove') as FnCallType,
+                arguments:[TXB_OBJECT(txb, repository), txb.pure(BCS_CONVERT.ser_vector_string(array_unique(policy_keys))), TXB_OBJECT(txb, permission)]
+            })                
         }
     }
+    return true;
 }
 // PermissionIndex.repository_description_set
-export function repository_set_description(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, description:string, passport?:PassportObject) {
+export function repository_set_description(txb:TransactionBlock, repository:RepositoryObject, permission:PermissionObject, 
+    description:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!IsValidDesription(description)) return false;
+
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.RepositoryFn('description_set_with_passport') as FnCallType,
-            arguments:[passport, repository, txb.pure(description_data(description)), permission]
+            arguments:[passport, TXB_OBJECT(txb, repository), txb.pure(description), TXB_OBJECT(txb, permission)]
         }) 
     } else {
         txb.moveCall({
             target:PROTOCOL.RepositoryFn('description_set') as FnCallType,
-            arguments:[repository, txb.pure(description_data(description)), permission]
+            arguments:[TXB_OBJECT(txb, repository), txb.pure(description), TXB_OBJECT(txb, permission)]
         }) 
     }        
+    return true
 }
 
-export function repository_set_policy_mode(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject, policy_mode:Repository_Policy_Mode, passport?:PassportObject) {
+export function repository_set_policy_mode(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject,
+    policy_mode:Repository_Policy_Mode, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
     if (passport) {
         txb.moveCall({
             target:PROTOCOL.RepositoryFn('policy_mode_set_with_passport') as FnCallType,
-            arguments:[passport, repository, txb.pure(policy_mode), permission]
+            arguments:[passport, TXB_OBJECT(txb, repository), txb.pure(policy_mode), TXB_OBJECT(txb, permission)]
         })  
     } else {
         txb.moveCall({
             target:PROTOCOL.RepositoryFn('policy_mode_set') as FnCallType,
-            arguments:[repository, txb.pure(policy_mode), permission]
+            arguments:[TXB_OBJECT(txb, repository), txb.pure(policy_mode), TXB_OBJECT(txb, permission)]
         })  
-    }     
+    }  
+    return true
 }
 
-export function repository_set_policy_description(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject, description:string, passport?:PassportObject) {
+export function repository_set_policy_description(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject, 
+    policy:string, description:string, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!IsValidKey(policy) || !IsValidDesription(description)) return false;
+
     if (passport) {
         txb.moveCall({
-            target:PROTOCOL.RepositoryFn('description_set_with_passport') as FnCallType,
-            arguments:[passport, repository, txb.pure(description_data(description)), permission]
+            target:PROTOCOL.RepositoryFn('policy_description_set_with_passport') as FnCallType,
+            arguments:[passport, TXB_OBJECT(txb, repository), txb.pure(policy), txb.pure(description), TXB_OBJECT(txb, permission)]
         })   
     } else {
         txb.moveCall({
-            target:PROTOCOL.RepositoryFn('description_set') as FnCallType,
-            arguments:[repository, txb.pure(description_data(description)), permission]
+            target:PROTOCOL.RepositoryFn('policy_description_set') as FnCallType,
+            arguments:[TXB_OBJECT(txb, repository), txb.pure(policy), txb.pure(description), TXB_OBJECT(txb, permission)]
         })   
     } 
+    return true;
 }
 
-export function repository_set_policy_permission(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject, permission_index:number, passport?:PassportObject) {
+export function repository_set_policy_permission(txb:TransactionBlock, repository: RepositoryObject, permission:PermissionObject, 
+    policy:string, permission_index?:number, passport?:PassportObject) : boolean {
+    if (!IsValidObjects([repository, permission])) return false;
+    if (!IsValidKey(policy)) return false;
+
+    let index = OptionNone(txb);
+    if (permission_index) {
+        if(!IsValidPermissionIndex(permission_index)) return false;
+        index = txb.pure(BCS_CONVERT.ser_option_u64(permission_index));
+    }
+
     if (passport) {
         txb.moveCall({
-            target:PROTOCOL.RepositoryFn('policy_mode_set_with_passport') as FnCallType,
-            arguments:[passport, repository, txb.pure(permission_index, BCS.U64), permission]
+            target:PROTOCOL.RepositoryFn('policy_permission_set_with_passport') as FnCallType,
+            arguments:[passport, TXB_OBJECT(txb, repository), index, TXB_OBJECT(txb, permission)]
         })   
     } else {
         txb.moveCall({
-            target:PROTOCOL.RepositoryFn('policy_mode_set') as FnCallType,
-            arguments:[repository, txb.pure(permission_index, BCS.U64), permission]
+            target:PROTOCOL.RepositoryFn('policy_permission_set') as FnCallType,
+            arguments:[TXB_OBJECT(txb, repository), index, TXB_OBJECT(txb, permission)]
         })   
     }     
+    return true
 }
 
 export function change_permission(txb:TransactionBlock, repository:RepositoryObject, old_permission:PermissionObject, new_permission:PermissionObject) {
+    if (!IsValidObjects([repository, old_permission, new_permission])) return false;
     txb.moveCall({
         target:PROTOCOL.RepositoryFn('permission_set') as FnCallType,
-        arguments: [repository, old_permission, new_permission],
+        arguments: [TXB_OBJECT(txb, repository), TXB_OBJECT(txb, old_permission), TXB_OBJECT(txb, new_permission)],
         typeArguments:[]            
     })    
 }
 
+