wowok 1.0.8 → 1.0.10

package/README.md

@@ -3,7 +3,8 @@
 
 AI-oriented web3 collaboration protocol, driving innovaion and making it more likely to happen.
 
-[Github](https://github.com/wowok-ai/sdk)
+Github: [https://github.com/wowok-ai/sdk](https://github.com/wowok-ai/sdk)
+Examples: [https://github.com/wowok-ai/sdk-examples](https://github.com/wowok-ai/sdk-examples)
 
 ### Installation
 

package/dist/demand.d.ts

@@ -0,0 +1,26 @@
+import { type TransactionResult } from '@mysten/sui.js/transactions';
+import { Protocol, PassportObject, PermissionObject, GuardObject, DemandAddress, TxbObject } from './protocol';
+import { Service } from './service';
+export declare class Demand {
+    protected earnest_type: string;
+    protected permission: PermissionObject;
+    protected object: TxbObject;
+    protected protocol: Protocol;
+    get_earnest_type(): string;
+    get_object(): TxbObject;
+    static From(protocol: Protocol, earnest_type: string, permission: PermissionObject, object: TxbObject): Demand;
+    private constructor();
+    static New(protocol: Protocol, earnest_type: string, permission: PermissionObject, description: string, earnest: TransactionResult, passport?: PassportObject): Demand;
+    launch(): DemandAddress;
+    destroy(): void;
+    refund(passport?: PassportObject): void;
+    expand_time(minutes_duration: number, passport?: PassportObject): void;
+    set_guard(guard?: GuardObject, passport?: PassportObject): void;
+    set_description(description: string, passport?: PassportObject): boolean;
+    yes(service_id: string, passport?: PassportObject): void;
+    deposit(earnest: TxbObject): void;
+    present(service: Service, tips: string, passport?: PassportObject): boolean;
+    change_permission(new_permission: PermissionObject): boolean;
+    static MAX_EARNEST_COUNT: number;
+    static MAX_PRESENTERS_COUNT: number;
+}

package/dist/demand.js

@@ -1,237 +1,242 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.change_permission = exports.present = exports.deposit = exports.demand_yes = exports.demand_set_description = exports.demand_set_guard = exports.demand_expand_time = exports.demand_refund = exports.destroy = exports.launch = exports.demand = exports.MAX_PRESENTERS_COUNT = exports.MAX_EARNEST_COUNT = void 0;
+exports.Demand = void 0;
 const bcs_1 = require("@mysten/bcs");
 const protocol_1 = require("./protocol");
-exports.MAX_EARNEST_COUNT = 200;
-exports.MAX_PRESENTERS_COUNT = 200;
-function demand(earnest_type, txb, permission, description, earnest, passport) {
-    if (!(0, protocol_1.IsValidObjects)([permission, earnest]))
-        return false;
-    if (!(0, protocol_1.IsValidDesription)(description) || !(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (passport) {
-        return txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('new_with_passport'),
-            arguments: [passport, txb.pure(description), earnest, (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
-    }
-    else {
-        return txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('new'),
-            arguments: [txb.pure(description), earnest, (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+const utils_1 = require("./utils");
+const exception_1 = require("./exception");
+class Demand {
+    earnest_type;
+    permission;
+    object;
+    protocol;
+    get_earnest_type() { return this.earnest_type; }
+    get_object() { return this.object; }
+    static From(protocol, earnest_type, permission, object) {
+        let d = new Demand(protocol, earnest_type, permission);
+        d.object = protocol_1.Protocol.TXB_OBJECT(protocol.CurrentSession(), object);
+        return d;
     }
-}
-exports.demand = demand;
-function launch(earnest_type, txb, demand) {
-    if (!(0, protocol_1.IsValidObjects)([demand]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    return txb.moveCall({
-        target: protocol_1.PROTOCOL.DemandFn('create'),
-        arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand)],
-        typeArguments: [earnest_type],
-    });
-}
-exports.launch = launch;
-function destroy(earnest_type, txb, demand) {
-    if (!(0, protocol_1.IsValidObjects)([demand]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    txb.moveCall({
-        target: protocol_1.PROTOCOL.DemandFn('destroy'),
-        arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand)],
-        typeArguments: [earnest_type]
-    });
-    return true;
-}
-exports.destroy = destroy;
-function demand_refund(earnest_type, txb, demand, permission, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (passport) {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('refund_with_passport'),
-            arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), txb.object(protocol_1.CLOCK_OBJECT), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+    constructor(protocol, earnest_type, permission) {
+        this.earnest_type = earnest_type;
+        this.permission = permission;
+        this.protocol = protocol;
+        this.object = '';
     }
-    else {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('refund'),
-            arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), txb.object(protocol_1.CLOCK_OBJECT), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+    static New(protocol, earnest_type, permission, description, earnest, passport) {
+        let d = new Demand(protocol, earnest_type, permission);
+        if (!protocol_1.Protocol.IsValidObjects([permission, earnest])) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidObjects, 'permission, earnest');
+        }
+        if (!(0, utils_1.IsValidDesription)(description)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidDesription);
+        }
+        if (!(0, utils_1.IsValidArgType)(earnest_type)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidArgType, earnest_type);
+        }
+        let txb = protocol.CurrentSession();
+        if (passport) {
+            d.object = txb.moveCall({
+                target: protocol.DemandFn('new_with_passport'),
+                arguments: [passport, txb.pure(description), earnest, protocol_1.Protocol.TXB_OBJECT(txb, permission)],
+                typeArguments: [earnest_type],
+            });
+        }
+        else {
+            d.object = txb.moveCall({
+                target: protocol.DemandFn('new'),
+                arguments: [txb.pure(description), earnest, protocol_1.Protocol.TXB_OBJECT(txb, permission)],
+                typeArguments: [earnest_type],
+            });
+        }
+        return d;
     }
-    return true;
-}
-exports.demand_refund = demand_refund;
-function demand_expand_time(earnest_type, txb, demand, permission, minutes_duration, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (!(0, protocol_1.IsValidUint)(minutes_duration))
-        return false;
-    if (passport) {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('time_expand_with_passport'),
-            arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(minutes_duration, bcs_1.BCS.U64), txb.object(protocol_1.CLOCK_OBJECT), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
+    launch() {
+        let txb = this.protocol.CurrentSession();
+        return txb.moveCall({
+            target: this.protocol.DemandFn('create'),
+            arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object)],
+            typeArguments: [this.earnest_type],
         });
     }
-    else {
+    destroy() {
+        let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('time_expand'),
-            arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(minutes_duration, bcs_1.BCS.U64), txb.object(protocol_1.CLOCK_OBJECT), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
+            target: this.protocol.DemandFn('destroy'),
+            arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object)],
+            typeArguments: [this.earnest_type]
         });
     }
-    return true;
-}
-exports.demand_expand_time = demand_expand_time;
-function demand_set_guard(earnest_type, txb, demand, permission, guard, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (passport) {
-        if (guard) {
+    refund(passport) {
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
             txb.moveCall({
-                target: protocol_1.PROTOCOL.DemandFn('guard_set_with_passport'),
-                arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, guard), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-                typeArguments: [earnest_type],
+                target: this.protocol.DemandFn('refund_with_passport'),
+                arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.object(protocol_1.Protocol.CLOCK_OBJECT), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
             });
         }
         else {
             txb.moveCall({
-                target: protocol_1.PROTOCOL.DemandFn('guard_none_with_passport'),
-                arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-                typeArguments: [earnest_type],
+                target: this.protocol.DemandFn('refund'),
+                arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.object(protocol_1.Protocol.CLOCK_OBJECT), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
             });
         }
     }
-    else {
-        if (guard) {
+    expand_time(minutes_duration, passport) {
+        if (!(0, utils_1.IsValidUint)(minutes_duration)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidUint, 'minutes_duration');
+        }
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
             txb.moveCall({
-                target: protocol_1.PROTOCOL.DemandFn('guard_set'),
-                arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, guard), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-                typeArguments: [earnest_type],
+                target: this.protocol.DemandFn('time_expand_with_passport'),
+                arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_duration, bcs_1.BCS.U64),
+                    txb.object(protocol_1.Protocol.CLOCK_OBJECT), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
             });
         }
         else {
             txb.moveCall({
-                target: protocol_1.PROTOCOL.DemandFn('guard_none'),
-                arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-                typeArguments: [earnest_type],
+                target: this.protocol.DemandFn('time_expand'),
+                arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(minutes_duration, bcs_1.BCS.U64),
+                    txb.object(protocol_1.Protocol.CLOCK_OBJECT), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
             });
         }
     }
-    return true;
-}
-exports.demand_set_guard = demand_set_guard;
-function demand_set_description(earnest_type, txb, demand, permission, description, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (!(0, protocol_1.IsValidDesription)(description))
-        return false;
-    if (passport) {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('description_set_with_passport'),
-            arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(description), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+    set_guard(guard, passport) {
+        if (guard && !protocol_1.Protocol.IsValidObjects([guard])) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidObjects, 'guard');
+        }
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            if (guard) {
+                txb.moveCall({
+                    target: this.protocol.DemandFn('guard_set_with_passport'),
+                    arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, guard),
+                        protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                    typeArguments: [this.earnest_type],
+                });
+            }
+            else {
+                txb.moveCall({
+                    target: this.protocol.DemandFn('guard_none_with_passport'),
+                    arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                    typeArguments: [this.earnest_type],
+                });
+            }
+        }
+        else {
+            if (guard) {
+                txb.moveCall({
+                    target: this.protocol.DemandFn('guard_set'),
+                    arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, guard),
+                        protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                    typeArguments: [this.earnest_type],
+                });
+            }
+            else {
+                txb.moveCall({
+                    target: this.protocol.DemandFn('guard_none'),
+                    arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                    typeArguments: [this.earnest_type],
+                });
+            }
+        }
     }
-    else {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('description_set'),
-            arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(description), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+    set_description(description, passport) {
+        if (!(0, utils_1.IsValidDesription)(description)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidDesription);
+        }
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target: this.protocol.DemandFn('description_set_with_passport'),
+                arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(description),
+                    protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
+            });
+        }
+        else {
+            txb.moveCall({
+                target: this.protocol.DemandFn('description_set'),
+                arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(description), protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
+            });
+        }
+        return true;
     }
-    return true;
-}
-exports.demand_set_description = demand_set_description;
-function demand_yes(earnest_type, txb, demand, permission, service_id, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (!(0, protocol_1.IsValidAddress)(service_id))
-        return false;
-    if (passport) {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('yes_with_passport'),
-            arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(service_id, bcs_1.BCS.ADDRESS), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
-        });
+    yes(service_id, passport) {
+        if (!(0, utils_1.IsValidAddress)(service_id)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidAddress);
+        }
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target: this.protocol.DemandFn('yes_with_passport'),
+                arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(service_id, bcs_1.BCS.ADDRESS),
+                    protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
+            });
+        }
+        else {
+            txb.moveCall({
+                target: this.protocol.DemandFn('yes'),
+                arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), txb.pure(service_id, bcs_1.BCS.ADDRESS),
+                    protocol_1.Protocol.TXB_OBJECT(txb, this.permission)],
+                typeArguments: [this.earnest_type],
+            });
+        }
     }
-    else {
+    deposit(earnest) {
+        if (!protocol_1.Protocol.IsValidObjects([earnest])) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidObjects);
+        }
+        let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('yes'),
-            arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), txb.pure(service_id, bcs_1.BCS.ADDRESS), (0, protocol_1.TXB_OBJECT)(txb, permission)],
-            typeArguments: [earnest_type],
+            target: this.protocol.DemandFn('deposit'),
+            arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, earnest)],
+            typeArguments: [this.earnest_type],
         });
     }
-    return true;
-}
-exports.demand_yes = demand_yes;
-function deposit(earnest_type, txb, demand, earnest) {
-    if (!(0, protocol_1.IsValidObjects)([demand, earnest]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    txb.moveCall({
-        target: protocol_1.PROTOCOL.DemandFn('deposit'),
-        arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, earnest)],
-        typeArguments: [earnest_type],
-    });
-    return true;
-}
-exports.deposit = deposit;
-function present(earnest_type, service_type, txb, demand, service, tips, passport) {
-    if (!(0, protocol_1.IsValidObjects)([demand, service]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    if (!(0, protocol_1.IsValidDesription)(tips))
-        return false;
-    if (passport) {
-        txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('present_with_passport'),
-            arguments: [passport, (0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, service), txb.pure(tips, bcs_1.BCS.STRING),],
-            typeArguments: [earnest_type, service_type],
-        });
+    present(service, tips, passport) {
+        if (!(0, utils_1.IsValidDesription)(tips)) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidDesription, 'tips');
+        }
+        let txb = this.protocol.CurrentSession();
+        if (passport) {
+            txb.moveCall({
+                target: this.protocol.DemandFn('present_with_passport'),
+                arguments: [passport, protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, service.get_object()),
+                    txb.pure(tips, bcs_1.BCS.STRING),],
+                typeArguments: [this.earnest_type, service.get_pay_type()],
+            });
+        }
+        else {
+            txb.moveCall({
+                target: this.protocol.DemandFn('present'),
+                arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, service.get_object()),
+                    txb.pure(tips, bcs_1.BCS.STRING),],
+                typeArguments: [this.earnest_type, service.get_pay_type()],
+            });
+        }
+        return true;
     }
-    else {
+    change_permission(new_permission) {
+        if (!protocol_1.Protocol.IsValidObjects([new_permission])) {
+            (0, exception_1.ERROR)(exception_1.Errors.IsValidObjects);
+        }
+        let txb = this.protocol.CurrentSession();
         txb.moveCall({
-            target: protocol_1.PROTOCOL.DemandFn('present'),
-            arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, service), txb.pure(tips, bcs_1.BCS.STRING),],
-            typeArguments: [earnest_type, service_type],
+            target: this.protocol.DemandFn('permission_set'),
+            arguments: [protocol_1.Protocol.TXB_OBJECT(txb, this.object), protocol_1.Protocol.TXB_OBJECT(txb, this.permission), protocol_1.Protocol.TXB_OBJECT(txb, new_permission)],
+            typeArguments: [this.earnest_type]
         });
+        return true;
     }
-    return true;
-}
-exports.present = present;
-function change_permission(earnest_type, txb, demand, old_permission, new_permission) {
-    if (!(0, protocol_1.IsValidObjects)([demand, old_permission, new_permission]))
-        return false;
-    if (!(0, protocol_1.IsValidArgType)(earnest_type))
-        return false;
-    txb.moveCall({
-        target: protocol_1.PROTOCOL.DemandFn('permission_set'),
-        arguments: [(0, protocol_1.TXB_OBJECT)(txb, demand), (0, protocol_1.TXB_OBJECT)(txb, old_permission), (0, protocol_1.TXB_OBJECT)(txb, new_permission)],
-        typeArguments: [earnest_type]
-    });
-    return true;
+    static MAX_EARNEST_COUNT = 200;
+    static MAX_PRESENTERS_COUNT = 200;
 }
-exports.change_permission = change_permission;
+exports.Demand = Demand;

package/dist/exception.d.ts

@@ -0,0 +1,18 @@
+export declare enum Errors {
+    IsValidDesription = "invalid description",
+    IsValidName = "invalid name",
+    IsValidName_AllowEmpty = "invalid name",
+    IsValidEndpoint = "invalid endpoint",
+    IsValidAddress = "invalid address",
+    IsValidArgType = "invalid argumentType",
+    IsValidUint = "invalid uint",
+    IsValidInt = "invalid int",
+    IsValidPercent = "invalid percent",
+    IsValidArray = "invalid array",
+    IsValidObjects = "invalid objects",
+    AllInvalid = "one valid at least",
+    InvalidParam = "invalid parameter",
+    IsValidPermissionIndex = "invalid permission index",
+    IsValidKey = "invalid key"
+}
+export declare const ERROR: (error: Errors, info?: any) => never;

package/dist/exception.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR = exports.Errors = void 0;
+var Errors;
+(function (Errors) {
+    Errors["IsValidDesription"] = "invalid description";
+    Errors["IsValidName"] = "invalid name";
+    Errors["IsValidName_AllowEmpty"] = "invalid name";
+    Errors["IsValidEndpoint"] = "invalid endpoint";
+    Errors["IsValidAddress"] = "invalid address";
+    Errors["IsValidArgType"] = "invalid argumentType";
+    Errors["IsValidUint"] = "invalid uint";
+    Errors["IsValidInt"] = "invalid int";
+    Errors["IsValidPercent"] = "invalid percent";
+    Errors["IsValidArray"] = "invalid array";
+    Errors["IsValidObjects"] = "invalid objects";
+    Errors["AllInvalid"] = "one valid at least";
+    Errors["InvalidParam"] = "invalid parameter";
+    Errors["IsValidPermissionIndex"] = "invalid permission index";
+    Errors["IsValidKey"] = "invalid key";
+})(Errors || (exports.Errors = Errors = {}));
+const ERROR = (error, info) => {
+    const e = error + info ? (': ' + info) : '';
+    throw e;
+};
+exports.ERROR = ERROR;

package/dist/graphql.d.ts

@@ -0,0 +1,4 @@
+export declare const GRAPHQL_OBJECTS_TYPE: import("graphql/language/ast").DocumentNode;
+export declare const GRAPHQL_OBJECT: import("graphql/language/ast").DocumentNode;
+export declare const GRAPHQL_OWNER: import("graphql/language/ast").DocumentNode;
+export declare const GRAPHQL_OBJECTS: import("graphql/language/ast").DocumentNode;

package/dist/guard.d.ts

@@ -0,0 +1,46 @@
+import { Protocol, GuardAddress, Data_Type, MODULES, ContextType, ValueType, OperatorType } from './protocol';
+export declare enum Guard_Sense_Binder {
+    AND = 0,
+    OR = 1
+}
+export type Guard_Sense = {
+    input: Uint8Array;
+    notAfterSense: boolean;
+    binder: Guard_Sense_Binder;
+};
+export type VariableType = Map<number, Guard_Vriable>;
+export type Guard_Vriable = {
+    type: ContextType | OperatorType;
+    value?: Uint8Array;
+    witness?: Uint8Array;
+};
+export type Guard_Creation = {
+    description: string;
+    variables?: VariableType;
+    senses: Guard_Sense[];
+};
+export declare class Guard {
+    static MAX_SENSE_COUNT: number;
+    static IsValidGuardVirableType: (type: OperatorType | ContextType) => boolean;
+    static IsValidIndentifier: (identifier: number) => boolean;
+    static get_variable_value(variables: VariableType, identifier: number, type: OperatorType | ContextType): Uint8Array | boolean;
+    static get_variable_witness(variables: VariableType, identifier: number, type: OperatorType | ContextType): Uint8Array | boolean;
+    static add_future_variable(variables: VariableType, identifier: number, type: OperatorType | ContextType, witness: any, value?: any, bNeedSerialize?: boolean): boolean;
+    static add_variable(variables: VariableType, identifier: number, type: OperatorType | ContextType, value: any, bNeedSerialize?: boolean): boolean;
+    static launch(protocol: Protocol, creation: Guard_Creation): GuardAddress;
+    static signer_guard(protocol: Protocol): GuardAddress;
+    static everyone_guard(protocol: Protocol): GuardAddress;
+    static QUERIES: any[];
+}
+export declare class SenseMaker {
+    protected data: Uint8Array[];
+    protected type_validator: Data_Type[];
+    constructor();
+    add_param(type: ValueType | ContextType, param?: any, variable?: VariableType): boolean;
+    static query_index(module: MODULES, query_name: string): number;
+    add_future_query(identifier: number, module: MODULES, query_name: string, variable: VariableType): boolean;
+    add_query(module: MODULES, query_name: string, object_address_from: string | number): boolean;
+    add_logic(type: OperatorType): boolean;
+    make(bNotAfterSense?: boolean, binder?: Guard_Sense_Binder): boolean | Guard_Sense;
+    static match_u128(type: number): boolean;
+}