wowok 1.7.13 → 1.7.16

package/src/demand.ts

@@ -1,300 +0,0 @@
-import { Transaction as TransactionBlock } from '@mysten/sui/transactions';
-import { FnCallType, Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject, ServiceObject } from './protocol.js';
-import { IsValidDesription, IsValidAddress, IsValidArgType, IsValidU64, parseObjectType, IsValidU8, IsValidLocation } from './utils.js'
-import { Errors, ERROR}  from './exception.js'
-
-export class Demand {
-    protected bounty_type;
-    protected permission ;
-    protected object : TxbObject;
-    protected txb;
-
-    get_bounty_type() {  return this.bounty_type }
-    get_object() { return this.object }
-
-    static From(txb:TransactionBlock, bounty_type:string, permission:PermissionObject, object:TxbObject) : Demand {
-        let d = new Demand(txb,  bounty_type, permission)
-        d.object = Protocol.TXB_OBJECT(txb, object)
-        return d
-    }   
-
-    private constructor(txb:TransactionBlock, bounty_type:string, permission:PermissionObject) {
-        this.bounty_type = bounty_type;
-        this.permission = permission;
-        this.txb = txb;
-        this.object = '';
-    }
-    static New(txb:TransactionBlock, bounty_type:string, minutes_duration:boolean, time:number, permission:PermissionObject, description:string, 
-        passport?:PassportObject) : Demand {
-        if (!IsValidDesription(description)) {
-            ERROR(Errors.IsValidDesription);
-        } 
-        if (!IsValidArgType(bounty_type)) {
-            ERROR(Errors.IsValidArgType, bounty_type);
-        }
-        if (!IsValidU64(time)) {
-            ERROR(Errors.IsValidUint, 'time')
-        }
-        
-        let  d = new Demand(txb, bounty_type, permission);
-        const clock = txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
-        if (minutes_duration) time = time * 1000 * 60; //@ duration minutes
-        if (passport) {
-            d.object = txb.moveCall({
-                target:Protocol.Instance().demandFn('new_with_passport') as FnCallType,
-                arguments:[passport, txb.pure.string(description), txb.pure.bool(minutes_duration), txb.pure.u64(time), 
-                    txb.object(clock), Protocol.TXB_OBJECT(txb, permission)],
-                typeArguments:[bounty_type],
-            })        
-        } else {
-            d.object = txb.moveCall({
-                target:Protocol.Instance().demandFn('new') as FnCallType,
-                arguments:[txb.pure.string(description), txb.pure.bool(minutes_duration), txb.pure.u64(time), 
-                    txb.object(clock), Protocol.TXB_OBJECT(txb, permission)],
-                typeArguments:[bounty_type],
-            })        
-        }
-        return d
-    }
-
-    launch() : DemandAddress {
-        return this.txb.moveCall({
-            target:Protocol.Instance().demandFn('create') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)],
-            typeArguments:[this.bounty_type],
-        })
-    }
-    
-    refund(passport?:PassportObject)  {
-        const clock = this.txb.sharedObjectRef(Protocol.CLOCK_OBJECT);
-        if (passport) {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('refund_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('refund') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.object(clock), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })            
-        }
-    }
-    
-    // minutes_duration TRUE , time is minutes count; otherwise, the deadline time
-    expand_time(minutes_duration:boolean, time: number, passport?:PassportObject) {
-        if (!IsValidU64(time)) {
-            ERROR(Errors.IsValidUint, `expand_time.time ${time}`);
-        }
-        if (minutes_duration) time = time * 1000 * 60; //@ duration minutes
-        if (passport) {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('time_expand_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.bool(minutes_duration),
-                    this.txb.pure.u64(time), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })  
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('time_expand') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object),  this.txb.pure.bool(minutes_duration),
-                    this.txb.pure.u64(time), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })          
-        }
-    }
-    
-   set_guard(guard?:GuardObject, service_identifier?:number, passport?:PassportObject)  {  
-        if (guard && !Protocol.IsValidObjects([guard])) {
-            ERROR(Errors.IsValidObjects, 'guard');
-        }
-        if (service_identifier !== undefined && !IsValidU8(service_identifier)) {
-            ERROR(Errors.InvalidParam, 'set_guard.service_identifier');
-        }
-        let id =  this.txb.pure.option('u8', service_identifier !== undefined ? service_identifier : undefined);
-
-        if (passport) {
-            if (guard) {
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('guard_set_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, guard), id, 
-                        Protocol.TXB_OBJECT(this.txb, this.permission)],
-                    typeArguments:[this.bounty_type],
-                })            
-            } else {
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('guard_none_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                    typeArguments:[this.bounty_type],
-                })               
-            }
-        } else {
-            if (guard) {
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('guard_set') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, guard), id, 
-                        Protocol.TXB_OBJECT(this.txb, this.permission)],
-                    typeArguments:[this.bounty_type],
-                })            
-            } else {
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('guard_none') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                    typeArguments:[this.bounty_type],
-                })               
-            }        
-        }
-    }
-    
-    set_location(location:string, passport?:PassportObject) {
-        if (!IsValidLocation(location)) {
-            ERROR(Errors.IsValidLocation, `Demand.set_location.location ${location}`);
-        }
-        if (passport) {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('location_set_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(location), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('location_set') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(location), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        }
-    }
-
-    set_description(description:string, passport?:PassportObject) {
-        if (!IsValidDesription(description)) {
-            ERROR(Errors.IsValidDesription);
-        }
-    
-        if (passport) {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('description_set_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('description_set') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description), Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        }
-    }
-    
-    yes(service_address:string, passport?:PassportObject) {
-        if (!IsValidAddress(service_address)) {
-            ERROR(Errors.IsValidAddress, 'yes.service_address')
-
-        }
-
-        if (passport) {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('yes_with_passport') as FnCallType,
-                arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure.address(service_address), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        } else {
-            this.txb.moveCall({
-                target:Protocol.Instance().demandFn('yes') as FnCallType,
-                arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                    this.txb.pure.address(service_address), 
-                    Protocol.TXB_OBJECT(this.txb, this.permission)],
-                typeArguments:[this.bounty_type],
-            })    
-        }
-    }
-    
-    deposit(bounty:TxbObject)  {
-        if (!Protocol.IsValidObjects([bounty])) {
-            ERROR(Errors.IsValidObjects)
-        }
-        
-        this.txb.moveCall({
-            target:Protocol.Instance().demandFn('deposit') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, bounty)],
-            typeArguments:[this.bounty_type],
-        })    
-    }
-    
-    present(service: ServiceObject | number, service_pay_type?:string | null, tips?:string, passport?:PassportObject) {
-        tips = tips ?? '';
-        if (!IsValidDesription(tips)) {
-            ERROR(Errors.IsValidDesription, 'present.tips')
-        }
-        if (service_pay_type && !IsValidArgType(service_pay_type)) {
-            ERROR(Errors.IsValidArgType, 'service_pay_type')
-        }
-        if (typeof(service) === 'number') {
-            if (!IsValidU8(service) || !passport) {
-                ERROR(Errors.IsValidU8, 'present.service or present.passport')
-            }
-        } else {
-            if (!Protocol.IsValidObjects([service])) {
-                ERROR(Errors.IsValidObjects, 'present.service')
-            }
-        }
-
-        if (passport) {
-            if (typeof(service) === 'number') {
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('present_with_passport2') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(tips)],
-                    typeArguments:[this.bounty_type],
-                })  
-            } else {
-                if (!service_pay_type) {
-                    ERROR(Errors.InvalidParam, 'present.service_pay_type')  
-                }
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('present_with_passport') as FnCallType,
-                    arguments:[passport, Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, service), 
-                        this.txb.pure.string(tips)],
-                    typeArguments:[this.bounty_type, service_pay_type!],
-                })  
-            }
- 
-        } else {
-            if (typeof(service) !== 'number') {
-                if(!service_pay_type) {
-                    ERROR(Errors.InvalidParam, 'present.service_pay_type')  
-                }
-                this.txb.moveCall({
-                    target:Protocol.Instance().demandFn('present') as FnCallType,
-                    arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, service), 
-                        this.txb.pure.string(tips)],
-                    typeArguments:[this.bounty_type, service_pay_type!],
-                })                   
-            }
-        } 
-    }
-    change_permission(new_permission:PermissionObject)  {
-        if (!Protocol.IsValidObjects([new_permission])) {
-            ERROR(Errors.IsValidObjects)
-        }
-    
-        this.txb.moveCall({
-            target:Protocol.Instance().demandFn('permission_set') as FnCallType,
-            arguments: [Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, this.permission), Protocol.TXB_OBJECT(this.txb, new_permission)],
-            typeArguments:[this.bounty_type]            
-        })    
-        this.permission = new_permission
-    }
-    static parseObjectType = (chain_type?:string | null) : string =>  {
-        return parseObjectType(chain_type, 'demand::Demand<')
-    }
-
-    static MAX_BOUNTY_COUNT = 300;
-    static MAX_PRESENTERS_COUNT = 200;
-}
-

package/src/entity.ts

@@ -1,171 +0,0 @@
-import { Protocol, FnCallType, TxbObject, ResourceAddress, ResourceObject} from './protocol.js';
-import { IsValidDesription, IsValidAddress, IsValidName, Bcs, IsValidStringLength} from './utils.js';
-import { ERROR, Errors } from './exception.js';
-import { TagName, Resource } from './resource.js';
-import { Transaction as TransactionBlock, TransactionResult } from '@mysten/sui/transactions';
-
-export interface EntityData {
-    info?: Map<string, string>,
-    resource_object?: string,
-    like?: number,
-    dislike?: number,
-    address?:string,
-    description?: string,
-    lastActive_digest?: string,
-}
-
-export enum EntityInfo_Default {
-    name = 'name',
-    avatar = 'avatar',
-    x = 'x',
-    discord = 'discord',
-    location = 'location',
-    homepage = 'homepage'
-}
-
-export interface EntityInfo {
-    title: string;
-    value: string;
-}
-
-export class Entity {
-    protected object:TxbObject;
-    protected txb;
-
-    get_object() { return this.object }
-    private constructor(txb:TransactionBlock) {
-        this.txb = txb;
-        this.object = '';
-    }
-
-    static From(txb:TransactionBlock) : Entity {
-        let r = new Entity(txb);
-        r.object = Protocol.TXB_OBJECT(txb, Protocol.Instance().objectEntity());
-        return r
-    }
-
-    mark(resource:Resource, address:string | TransactionResult, like:TagName.Like | TagName.Dislike) {
-        if (typeof(address) === 'string' && !IsValidAddress(address)) {
-            ERROR(Errors.IsValidAddress, like);
-        }
-
-        this.txb.moveCall({
-            target:Protocol.Instance().entityFn(like) as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object()), 
-                typeof(address) === 'string' ? this.txb.pure.address(address) : address]
-        })
-    }
-
-    add_info(info: Map<string, string>) {
-        if (info.size === 0)  return ;
-
-        if (info.size > Entity.MAX_INFO_LENGTH) {
-            ERROR(Errors.IsValidValue, `Entity.update: info size too long ${info.size}`);
-        }
-
-        info.forEach((v, k) => {
-            if (!IsValidName(k)) {
-                ERROR(Errors.IsValidName, `Entity.update: ${k} key too long `);
-            }
-            if (!IsValidStringLength(v, Entity.MAX_INFO_VALUE_LENGTH)) {
-                ERROR(Errors.IsValidValue, `Entity.update: ${k} value too long`);
-            }   
-        })
-
-        const keys = Array.from(info.keys()).map(v => v.toLocaleLowerCase());
-        const values = Array.from(info.values());
-        
-        this.txb.moveCall({
-            target:Protocol.Instance().entityFn('info_add') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                this.txb.pure.vector('string', keys),
-                this.txb.pure.vector('string', values)]
-        })
-    }
-
-    remove_info(titles:string[]) {
-        if (titles.length === 0) return ;
-        const t = titles.map(v => v.toLowerCase());
-        this.txb.moveCall({
-            target:Protocol.Instance().entityFn('info_remove') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), 
-                this.txb.pure.vector('string', t)]
-        })
-    }
-
-    removeall_info() {
-        this.txb.moveCall({
-            target:Protocol.Instance().entityFn('info_removeall') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
-        })
-    }
-
-
-    create_resource() : ResourceAddress {
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('resource_create') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
-        })
-    }
-
-    create_resource2(): ResourceObject {
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('resource_create2') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object)]
-        }) 
-    }
-    
-    set_description(description:string) {
-        if (!IsValidDesription(description)) {
-            ERROR(Errors.IsValidDesription, 'Entity.set_description');
-        }
-
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('description_set') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), this.txb.pure.string(description)]
-        })
-    }
-
-    destroy_resource(resource:Resource) { // Resource must self-owned.
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('resource_destroy') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object())]
-        })
-    }
-
-    use_resource(resource:Resource) { // Resource must self-owned.
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('resource_use') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object())]
-        })
-    }
-
-    transfer_resource(resource:Resource, new_address:string) { // Resource must self-owned.
-        if (!IsValidAddress(new_address)) ERROR(Errors.IsValidAddress, 'transfer_resource');
-        
-        return this.txb.moveCall({
-            target:Protocol.Instance().entityFn('resource_transfer') as FnCallType,
-            arguments:[Protocol.TXB_OBJECT(this.txb, this.object), Protocol.TXB_OBJECT(this.txb, resource.get_object()), 
-                this.txb.pure.address(new_address)]
-        })   
-    }
-
-    static EntityData = async (address:string) : Promise<EntityData|undefined>=> {
-        if (IsValidAddress(address)) {
-            const res = await Protocol.Client().getDynamicFieldObject({
-                parentId:Protocol.Instance().objectEntity(), name:{type:'address', value:address}});
-
-            const content = (res?.data?.content as any)?.fields;
-            const info = new Map<string, string>();
-            (content?.value?.fields?.info?.fields?.contents as any)?.forEach((v:any) => {
-                info.set(v?.fields?.key, v?.fields?.value)
-            })
-
-            return {like:content?.value?.fields?.like, dislike:content?.value?.fields?.dislike, address: address,
-                resource_object: content?.value?.fields?.resource, lastActive_digest: res?.data?.previousTransaction ?? '', 
-                info : info, description:content?.value?.fields?.description}
-        }
-  } 
-  static MAX_INFO_LENGTH = 32;
-  static MAX_INFO_VALUE_LENGTH = 256; // The max length of each info value.
-}

package/src/exception.ts

@@ -1,37 +0,0 @@
-
-export enum Errors {
-    IsValidDesription = 'invalid description',
-    IsValidName = 'invalid name',
-    IsValidName_AllowEmpty = 'invalid name',
-    IsValidEndpoint = 'invalid endpoint',
-    IsValidAddress = 'invalid address',
-    IsValidArgType = 'invalid argument type',
-    IsValidTokenType = 'invalid token type',
-    IsValidUint = 'invalid uint',
-    IsValidInt = 'invalid int', 
-    IsValidU64 = 'invalid u64',
-    IsValidU8 = 'invalid u8',
-    IsValidPercent = 'invalid percent',
-    IsValidArray = 'invalid array',
-    IsValidObjects = 'invalid objects',
-    AllInvalid = 'one valid at least',
-    InvalidParam  = 'invalid parameter',
-    IsValidPermissionIndex = 'invalid permission index',
-    IsValidKey = 'invalid key',
-    Fail = 'fail',
-    IsValidIndentifier = 'indentifier invalid',
-    isValidHttpUrl = 'invalid url',
-    IsValidBizPermissionIndex = 'invalid biz-permission index',
-    bcsTypeInvalid = 'invalid bcs type',
-    IsValidServiceItemName = 'invalid service item name',
-    IsValidCoinType = 'not the coin type',
-    IsValidGuardIdentifier = 'guard identifier invalid',
-    noPermission = 'no permission',
-    IsValidValue = 'invalid value',
-    IsValidLocation = 'invalid location',
-}
-
-export const ERROR = (error:Errors, info?:any) =>  {
-    const e = error.toString() + (info ? (' ' + info) : '');
-    throw e;
-}