wowok 1.8.2 → 2.1.9

package/dist/esm/w/call/demand.js

@@ -0,0 +1,869 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { isValidWowAddress } from "../../utils/sui-types.js";
+import {
+  toTxObject,
+  toTxString,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  isValidLongName,
+  PackageAddress,
+  IsValidArgType,
+  MAX_LONG_NAME_LENGTH,
+  isValidU8,
+  GetObjectExisted,
+  GetObject,
+  GetObjectDescription,
+  ValueType,
+  parseValueType,
+  demandFn
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { GetAccountOrMark_Address } from "../local/index.js";
+import { LocalMark } from "../local/local.js";
+import { ObjectType } from "../query/object.js";
+import { query_received } from "../query/received.js";
+import { queryObjectsWithType, queryObjectWithType } from "../query/util.js";
+import { owner_receive, validObjects } from "../util.js";
+import { CallBase } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { create as permissionCreate } from "./permission.js";
+class CallDemand extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    this.data = data;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await GetObjectExisted(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        ObjectType.Demand,
+        this.object_address
+      );
+      if (!this.content)
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallDemand_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+    } else {
+      const n = GetObject(this.data.object);
+      this.permission_address = await GetObjectExisted(n?.permission);
+      this.new_permission_description = GetObjectDescription(
+        n?.permission
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const guards = [];
+    const perms = [];
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    if (this.permission_address && !this.object_address) {
+      add_perm(BuiltinPermissionIndex.DEMAND_NEW);
+    }
+    if (this.data.present?.by_guard != null) {
+      if (!this.content) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallDemand_Data.data.present.by_guard fail because the Demand content not ready"
+        );
+      }
+      this.data.present.by_guard = await LocalMark.Instance().get_address(
+        this.data.present.by_guard
+      );
+      if (this.data.present.by_guard) {
+        const f = this.content?.guards.find(
+          (v) => v.guard === this.data.present.by_guard
+        );
+        if (f) {
+          guards.push(this.data.present.by_guard);
+        } else {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `guard ${this.data.present.by_guard} not found in guards: ${this.content.guards.map((v) => v.guard)}`
+          );
+        }
+      } else if (this.content && this.content.guards.length > 0) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `guard is required when present guards ${this.content.guards.map((v) => v.guard)} is not empty`
+        );
+      }
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(BuiltinPermissionIndex.DEMAND_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.location != null) {
+      add_perm(BuiltinPermissionIndex.DEMAND_LOCATION);
+    }
+    if (this.permission_address && this.data?.rewards != null) {
+      add_perm(BuiltinPermissionIndex.DEMAND_REWARD);
+    }
+    if (this.permission_address && this.data?.feedback != null) {
+      add_perm(BuiltinPermissionIndex.DEMAND_FEEDBACK);
+    }
+    if (this.permission_address && this.data?.guards != null) {
+      add_perm(BuiltinPermissionIndex.DEMAND_GUARD);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(BuiltinPermissionIndex.DEMAND_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data.um !== void 0) {
+      add_perm(BuiltinPermissionIndex.DEMAND_UM);
+    }
+    if (this.permission_address || guards.length > 0) {
+      return await this.check_permission_and_call(
+        env,
+        this.permission_address,
+        perms,
+        guards
+      );
+    }
+    return await this.exec(env);
+  }
+  async operate(env, tx, passport, submission) {
+    let permission = this.permission_address;
+    let object = this.object_address;
+    if (!this.object_address) {
+      if (!permission) {
+        permission = newPermission(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newDemand(
+          tx,
+          toTxObject(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        "CallDemand_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data.present != null && this.content) {
+      if (this.data.present.by_guard) {
+        const f = this.content.guards.find(
+          (v) => v.guard === this.data.present.by_guard
+        );
+        if (f && f.service_identifier != null) {
+          const sub = submission?.find((v) => v.guard === this.data.present.by_guard)?.submission?.find(
+            (v) => Number(v.identifier) === Number(f.service_identifier)
+          );
+          const subValueType = sub ? parseValueType(sub.value_type) : void 0;
+          if (sub && subValueType === ValueType.Address && sub.value && isValidWowAddress(sub.value)) {
+            this.data.present.service = void 0;
+          } else {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `submission ${f.service_identifier} invalid in the guard ${this.data.present.by_guard}`
+            );
+          }
+        }
+      }
+      let serviceObject = void 0;
+      let serviceType = void 0;
+      if (typeof this.data.present.service === "string" && this.data.present.service) {
+        const serviceResult = await queryObjectWithType(
+          env,
+          this.data.present.service,
+          ObjectType.Service,
+          "service::Service"
+        );
+        if (serviceResult) {
+          serviceObject = serviceResult.object;
+          serviceType = serviceResult.type;
+        } else {
+          W_ERROR(
+            WErrors.InvalidParam,
+            `service ${this.data.present.service} not found`
+          );
+        }
+      }
+      present(
+        tx,
+        object,
+        this.data.present.recommend,
+        this.data.present.by_guard,
+        serviceObject,
+        serviceType,
+        passport
+      );
+    }
+    if (this.data?.description != null && this.object_address) {
+      description_set(
+        tx,
+        object,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data?.location != null) {
+      location_set(
+        tx,
+        object,
+        permission,
+        this.data.location,
+        passport
+      );
+    }
+    if (this.data?.rewards != null) {
+      switch (this.data?.rewards.op) {
+        case "set":
+        case "add": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          if (this.data.rewards.op === "set") {
+            reward_clear(tx, object, permission, passport);
+          }
+          let rewardResults = [];
+          if (this.data.rewards.objects.length > 0) {
+            rewardResults = await queryObjectsWithType(
+              env,
+              this.data.rewards.objects,
+              ObjectType.Reward,
+              "reward::Reward"
+            );
+          }
+          rewardResults.forEach((rewardResult) => {
+            reward_add(
+              tx,
+              object,
+              permission,
+              rewardResult.object,
+              rewardResult.type,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          const rewardAddrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.rewards.objects
+          );
+          reward_remove(
+            tx,
+            object,
+            permission,
+            rewardAddrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          reward_clear(tx, object, permission, passport);
+          break;
+        }
+      }
+    }
+    if (this.data?.feedback != null) {
+      if (this.data.feedback.length > MAX_FEEDBACK_COUNT) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `feedback count exceeds maximum limit ${MAX_FEEDBACK_COUNT}`
+        );
+      }
+      for (const v of this.data.feedback) {
+        const who = await GetAccountOrMark_Address(v.who);
+        if (who) {
+          feedback(
+            tx,
+            object,
+            permission,
+            who,
+            v.acceptance_score,
+            v.feedback,
+            passport
+          );
+        }
+      }
+    }
+    if (this.data?.guards != null) {
+      switch (this.data?.guards.op) {
+        case "set":
+        case "add": {
+          if (this.data.guards.guard.length > MAX_GUARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `guards count exceeds maximum limit ${MAX_GUARD_COUNT}`
+            );
+          }
+          if (this.data.guards.op === "set") {
+            guard_clear(tx, object, permission, passport);
+          }
+          for (const guard of this.data.guards.guard) {
+            const addr = await LocalMark.Instance().get_address(
+              guard.guard
+            );
+            if (addr) {
+              guard_add(
+                tx,
+                object,
+                permission,
+                addr,
+                guard.service_identifier,
+                passport
+              );
+            }
+          }
+          break;
+        }
+        case "remove": {
+          if (this.data.guards.guard.length > MAX_GUARD_COUNT) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `guards count exceeds maximum limit ${MAX_GUARD_COUNT}`
+            );
+          }
+          const guardAddrs = await LocalMark.Instance().get_many_address_availables(
+            this.data.guards.guard
+          );
+          guard_remove(
+            tx,
+            object,
+            permission,
+            guardAddrs,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          guard_clear(tx, object, permission, passport);
+          break;
+        }
+      }
+    }
+    if (this.data?.owner_receive != null && this.object_address) {
+      if (this.data.owner_receive === "recently") {
+        this.data.owner_receive = await query_received({
+          object: this.object_address,
+          all_type: true,
+          no_cache: env.no_cache,
+          network: env.network
+        });
+      }
+      await owner_receive(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${PackageAddress}::demand::${name}`,
+        passport
+      );
+    }
+    if (this.data.um !== void 0) {
+      let um_address = null;
+      if (this.data.um) {
+        um_address = await LocalMark.Instance().get_address(this.data.um) || null;
+        if (!um_address) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallDemand_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(tx, object, permission, um_address, passport);
+    }
+    if (!this.permission_address) {
+      const p = GetObject(this.data?.object);
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Permission,
+        permissionCreate(tx, permission),
+        GetObject(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        ObjectType.Demand,
+        create(tx, object),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+}
+const MAX_REWARD_COUNT = 20;
+const MAX_GUARD_COUNT = 20;
+const MAX_FEEDBACK_COUNT = 20;
+function create(tx, demand) {
+  validObjects([demand]);
+  return tx.moveCall({
+    target: demandFn("create"),
+    arguments: [toTxObject(tx, demand)]
+  });
+}
+function present(tx, demand, recommend, by_guard, service, service_type, passport) {
+  validObjects([demand, service, by_guard, passport]);
+  recommend = recommend || "";
+  if (typeof recommend === "string" && !isValidDescription(recommend)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Recommend exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (service && !IsValidArgType(service_type)) {
+    W_ERROR(
+      WErrors.IsValidArgType,
+      `Service type ${service_type} is not valid`
+    );
+  }
+  if (by_guard) {
+    if (!passport) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Passport is required when by_guard ${by_guard} is present`
+      );
+    }
+    if (service) {
+      tx.moveCall({
+        target: demandFn("present_service_with_passport"),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, by_guard),
+          toTxObject(tx, passport),
+          toTxString(tx, recommend),
+          toTxObject(tx, service),
+          tx.object.clock()
+        ],
+        typeArguments: [service_type]
+      });
+    } else {
+      tx.moveCall({
+        target: demandFn("present_with_passport"),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, by_guard),
+          toTxObject(tx, passport),
+          toTxString(tx, recommend),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else if (service) {
+    tx.moveCall({
+      target: demandFn("present_service"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxString(tx, recommend),
+        toTxObject(tx, service),
+        tx.object.clock()
+      ],
+      typeArguments: [service_type]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("present"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxString(tx, recommend),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function newDemand(tx, permission, description, passport) {
+  validObjects([permission, passport]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: demandFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: demandFn("new"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, demand, permission, description, passport) {
+  validObjects([demand, permission, passport]);
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description ${description} exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("description_set_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("description_set"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxString(tx, description)
+      ]
+    });
+  }
+}
+function location_set(tx, demand, permission, location, passport) {
+  validObjects([demand, permission, passport]);
+  if (typeof location === "string" && !isValidLongName(location)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Location ${location} exceeds maximum length ${MAX_LONG_NAME_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("location_set_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, location)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("location_set"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxString(tx, location)
+      ]
+    });
+  }
+}
+function guard_add(tx, demand, permission, guard, service_identifier, passport) {
+  validObjects([demand, permission, guard, passport]);
+  if (typeof service_identifier === "number") {
+    if (!isValidU8(service_identifier)) {
+      W_ERROR(
+        WErrors.IsValidU8,
+        `Service identifier ${service_identifier} is invalid`
+      );
+    }
+  }
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("guard_add_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, guard),
+        tx.pure.option("u8", service_identifier ?? null),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("guard_add"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, guard),
+        tx.pure.option("u8", service_identifier ?? null),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function guard_remove(tx, demand, permission, guards, passport) {
+  if (guards.length === 0) {
+    return;
+  }
+  validObjects([demand, permission, passport, ...guards]);
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("guard_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", guards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("guard_remove"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", guards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function guard_clear(tx, demand, permission, passport) {
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("guard_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("guard_clear"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function reward_add(tx, demand, permission, reward, reward_type, passport) {
+  validObjects([demand, permission, passport, reward]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(
+      WErrors.IsValidArgType,
+      `Reward type ${reward_type} is invalid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("reward_add_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("reward_add"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, reward),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function reward_remove(tx, demand, permission, rewards, passport) {
+  if (rewards.length === 0) {
+    return;
+  }
+  validObjects([demand, permission, passport, ...rewards]);
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("reward_remove_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("reward_remove"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        tx.pure.vector("address", rewards),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function reward_clear(tx, demand, permission, passport) {
+  validObjects([demand, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("reward_clear_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("reward_clear"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function feedback(tx, demand, permission, who, acceptance_score, feedback2, passport) {
+  validObjects([demand, permission, who, passport]);
+  if (typeof feedback2 === "string" && !isValidDescription(feedback2)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Feedback exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (typeof acceptance_score === "number" && !isValidU8(acceptance_score)) {
+    W_ERROR(
+      WErrors.IsValidU8,
+      `Acceptance score ${acceptance_score} is invalid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: demandFn("feedback_with_passport"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.address(who),
+        tx.pure.option("u8", acceptance_score ?? null),
+        tx.pure.string(feedback2 ?? ""),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: demandFn("feedback"),
+      arguments: [
+        toTxObject(tx, demand),
+        toTxObject(tx, permission),
+        tx.pure.address(who),
+        tx.pure.option("u8", acceptance_score ?? null),
+        tx.pure.string(feedback2 ?? ""),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function um_set(tx, demand, permission, um, passport) {
+  validObjects([demand, permission]);
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: demandFn(`um_set_with_passport`),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, permission),
+          passport,
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: demandFn(`um_set`),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, permission),
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: demandFn(`um_none_with_passport`),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: demandFn(`um_none`),
+        arguments: [
+          toTxObject(tx, demand),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ]
+      });
+    }
+  }
+}
+export {
+  CallDemand,
+  MAX_FEEDBACK_COUNT,
+  MAX_GUARD_COUNT,
+  MAX_REWARD_COUNT,
+  create,
+  description_set,
+  feedback,
+  guard_add,
+  guard_clear,
+  guard_remove,
+  location_set,
+  newDemand,
+  present,
+  reward_add,
+  reward_clear,
+  reward_remove,
+  um_set
+};