wowok 1.8.2 → 2.1.9

package/dist/cjs/w/call/repository.js

@@ -0,0 +1,1324 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var repository_exports = {};
+__export(repository_exports, {
+  CallRepository: () => CallRepository,
+  MAX_DATA_SIZE: () => MAX_DATA_SIZE,
+  MAX_ID_COUNT_ONCE: () => MAX_ID_COUNT_ONCE,
+  MAX_POLICY_COUNT: () => MAX_POLICY_COUNT,
+  MAX_POLICY_DESCRIPTION_LEN: () => MAX_POLICY_DESCRIPTION_LEN,
+  MAX_POLICY_GUARD_COUNT: () => MAX_POLICY_GUARD_COUNT,
+  MAX_REWARD_COUNT: () => MAX_REWARD_COUNT,
+  create: () => create,
+  data: () => data,
+  data_id_from: () => data_id_from,
+  data_remove: () => data_remove,
+  description_set: () => description_set,
+  newRepository: () => newRepository,
+  policy: () => policy,
+  policy_add: () => policy_add,
+  policy_clear: () => policy_clear,
+  policy_remove: () => policy_remove,
+  policy_set: () => policy_set,
+  reward_add: () => reward_add,
+  reward_clear: () => reward_clear,
+  reward_remove: () => reward_remove,
+  um_set: () => um_set
+});
+module.exports = __toCommonJS(repository_exports);
+var import_common = require("../common.js");
+var import_exception = require("../exception.js");
+var import_util = require("../util.js");
+var import_common2 = require("../common.js");
+var import_local = require("../local/index.js");
+var import_local2 = require("../local/local.js");
+var import_base = require("./base.js");
+var import_permission = require("./permission.js");
+var import_object = require("../query/object.js");
+var import_permission2 = require("./permission.js");
+var import_util2 = require("../query/util.js");
+var import_received = require("../query/received.js");
+const MAX_POLICY_DESCRIPTION_LEN = 500;
+const MAX_POLICY_COUNT = 50;
+const MAX_POLICY_GUARD_COUNT = 10;
+const MAX_DATA_SIZE = 40960;
+const MAX_ID_COUNT_ONCE = 100;
+const MAX_REWARD_COUNT = 20;
+class CallRepository extends import_base.CallBase {
+  constructor(data2) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    this.data = data2;
+  }
+  async prepare(env) {
+    await super.prepare(env);
+    if (!this.object_address) {
+      this.object_address = await (0, import_common2.GetObjectExisted)(this.data?.object);
+    }
+    if (this.object_address) {
+      await this.update_content(
+        env,
+        import_object.ObjectType.Repository,
+        this.object_address
+      );
+      if (!this.content)
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallRepository_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      if (!this.permission_address) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallRepository_Data.data.object.permission is empty"
+        );
+      }
+    } else {
+      const n = (0, import_common2.GetObject)(this.data.object);
+      this.permission_address = await (0, import_common2.GetObjectExisted)(n?.permission);
+      this.new_permission_description = (0, import_common2.GetObjectDescription)(
+        n?.permission
+      );
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const perms = [];
+    const guards = [];
+    const add_guard = (guard) => {
+      if (!guards.includes(guard)) {
+        guards.push(guard);
+      }
+    };
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    if (this.permission_address && !this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_NEW);
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.policies != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_POLICY);
+    }
+    if (this.data?.data_add != null) {
+      if (!this.content) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "CallRepository_Data.data.data_add fail because the Repository content not ready"
+        );
+      }
+      const p = this.content.policies.find(
+        (p2) => p2.name === this.data.data_add.name
+      );
+      if (!p) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Invalid policy name: ${this.data.data_add.name}`
+        );
+      }
+      if ("items" in this.data.data_add) {
+        for (const item of this.data.data_add.items) {
+          for (const keyData of item.data) {
+            let idAddress;
+            if (typeof keyData.id === "number" || typeof keyData.id === "bigint" || typeof keyData.id === "string") {
+              idAddress = (0, import_util.uint2address)(keyData.id);
+            } else {
+              const r = await (0, import_local.GetAccountOrMark_Address)(
+                keyData.id
+              );
+              if (!r) {
+                (0, import_exception.W_ERROR)(
+                  import_exception.WErrors.InvalidParam,
+                  `Invalid id address: ${keyData.id}`
+                );
+              }
+              idAddress = r;
+            }
+            keyData.id = idAddress;
+          }
+          if (item.write_guard) {
+            const guardAddress = await import_local2.LocalMark.Instance().get_address(
+              item.write_guard
+            );
+            if (guardAddress) {
+              if (!p.write_guard.find(
+                (g) => g.guard === guardAddress
+              )) {
+                (0, import_exception.W_ERROR)(
+                  import_exception.WErrors.InvalidParam,
+                  `${item.write_guard} (${guardAddress}) is not match in policy ${p.name} with write_guards: ${p.write_guard.map((g) => g.guard).join(", ")}`
+                );
+              }
+              item.write_guard = guardAddress;
+              add_guard(guardAddress);
+            } else {
+              (0, import_exception.W_ERROR)(
+                import_exception.WErrors.InvalidParam,
+                `Invalid write_guard address: ${item.write_guard}`
+              );
+            }
+          }
+        }
+      } else if (this.data.data_add.write_guard) {
+        const guardAddress = await import_local2.LocalMark.Instance().get_address(
+          this.data.data_add.write_guard
+        );
+        if (guardAddress) {
+          if (!p.write_guard.find((g) => g.guard === guardAddress)) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `Invalid write_guard address: ${this.data.data_add.write_guard} in policy ${p.name}`
+            );
+          }
+          this.data.data_add.write_guard = guardAddress;
+          add_guard(guardAddress);
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `Invalid write_guard address: ${this.data.data_add.write_guard}`
+          );
+        }
+      }
+    }
+    if (this.data?.data_remove != null) {
+      const p = this.content.policies.find(
+        (p2) => p2.name === this.data.data_remove.name
+      );
+      if (!p) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Invalid policy name: ${this.data.data_remove.name}`
+        );
+      }
+      if ("items" in this.data.data_remove) {
+        for (const item of this.data.data_remove.items) {
+          const idAddresses = [];
+          for (const id of item.id) {
+            let idAddress;
+            if (typeof id === "number" || typeof id === "bigint" || typeof id === "string") {
+              idAddress = (0, import_util.uint2address)(id);
+            } else {
+              const r = await (0, import_local.GetAccountOrMark_Address)(id);
+              if (!r) {
+                (0, import_exception.W_ERROR)(
+                  import_exception.WErrors.InvalidParam,
+                  `Invalid id address: ${id}`
+                );
+              }
+              idAddress = r;
+            }
+            idAddresses.push(idAddress);
+          }
+          item.id = idAddresses;
+          if (item.write_guard) {
+            const guardAddress = await import_local2.LocalMark.Instance().get_address(
+              item.write_guard
+            );
+            if (guardAddress) {
+              if (!p.write_guard.find(
+                (g) => g.guard === guardAddress
+              )) {
+                (0, import_exception.W_ERROR)(
+                  import_exception.WErrors.InvalidParam,
+                  `Invalid write_guard address: ${item.write_guard} in policy ${p.name}`
+                );
+              }
+              item.write_guard = guardAddress;
+              add_guard(guardAddress);
+            } else {
+              (0, import_exception.W_ERROR)(
+                import_exception.WErrors.InvalidParam,
+                `Invalid write_guard address: ${item.write_guard}`
+              );
+            }
+          }
+        }
+      } else {
+        if (this.data.data_remove.write_guard) {
+          const guardAddress = await import_local2.LocalMark.Instance().get_address(
+            this.data.data_remove.write_guard
+          );
+          if (guardAddress) {
+            if (!p.write_guard.find(
+              (g) => g.guard === guardAddress
+            )) {
+              (0, import_exception.W_ERROR)(
+                import_exception.WErrors.InvalidParam,
+                `Invalid write_guard address: ${this.data.data_remove.write_guard} in policy ${p.name}`
+              );
+            }
+            this.data.data_remove.write_guard = guardAddress;
+            add_guard(guardAddress);
+          } else {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `Invalid write_guard address: ${this.data.data_remove.write_guard}`
+            );
+          }
+        }
+      }
+    }
+    if (this.permission_address && this.data?.rewards != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_REWARD);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data?.um !== void 0) {
+      add_perm(import_permission.BuiltinPermissionIndex.REPOSITORY_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 = (0, import_permission.newPermission)(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission) {
+        object = newRepository(
+          tx,
+          (0, import_common.toTxObject)(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "CallRepository_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data?.description != null && this.object_address) {
+      description_set(
+        tx,
+        object,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data?.policies != null) {
+      if (this.data.policies.op === "set" || this.data.policies.op === "add") {
+        await Promise.all(
+          this.data.policies.policy.map(async (p) => {
+            await Promise.all(
+              p.write_guard.map(async (g) => {
+                const r = await import_local2.LocalMark.Instance().get_address(
+                  g.guard
+                );
+                if (r) {
+                  g.guard = r;
+                } else {
+                  (0, import_exception.W_ERROR)(
+                    import_exception.WErrors.InvalidParam,
+                    `Invalid write_guard address: ${g.guard}`
+                  );
+                }
+              })
+            );
+            if (p.quote_guard && typeof p.quote_guard === "string") {
+              const r = await import_local2.LocalMark.Instance().get_address(
+                p.quote_guard
+              );
+              if (r) {
+                p.quote_guard = r;
+              } else {
+                (0, import_exception.W_ERROR)(
+                  import_exception.WErrors.InvalidParam,
+                  `Invalid quote_guard address: ${p.quote_guard}`
+                );
+              }
+            }
+          })
+        );
+      }
+      switch (this.data.policies.op) {
+        case "set": {
+          policy_set(
+            tx,
+            object,
+            permission,
+            this.data.policies.policy,
+            passport
+          );
+          break;
+        }
+        case "add": {
+          policy_add(
+            tx,
+            object,
+            permission,
+            this.data.policies.policy,
+            passport
+          );
+          break;
+        }
+        case "remove": {
+          policy_remove(
+            tx,
+            object,
+            permission,
+            this.data.policies.policy,
+            passport
+          );
+          break;
+        }
+        case "clear": {
+          policy_clear(tx, object, permission, passport);
+          break;
+        }
+      }
+    }
+    if (this.data?.data_add != null && this.content) {
+      const policy2 = this.content.policies.find(
+        (p) => p.name === this.data.data_add.name
+      );
+      if (!policy2) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `policy ${this.data.data_add.name} not found in policies ${this.content.policies.map((p) => p.name)}`
+        );
+      }
+      if ("items" in this.data.data_add) {
+        data(tx, object, policy2, this.data.data_add.items, passport);
+      } else {
+        data_id_from(
+          tx,
+          object,
+          policy2,
+          this.data.data_add,
+          passport
+        );
+      }
+    }
+    if (this.data?.data_remove != null) {
+      const policy2 = this.content.policies.find(
+        (p) => p.name === this.data.data_remove.name
+      );
+      if (!policy2) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `policy ${this.data.data_remove.name} not found in policies ${this.content.policies.map((p) => p.name)}`
+        );
+      }
+      if ("items" in this.data.data_remove) {
+        data_remove(
+          tx,
+          object,
+          policy2,
+          { items: this.data.data_remove.items },
+          passport
+        );
+      } else {
+        data_remove(
+          tx,
+          object,
+          policy2,
+          { write_guard: this.data.data_remove.write_guard },
+          passport
+        );
+      }
+    }
+    if (this.data?.rewards != null) {
+      switch (this.data.rewards.op) {
+        case "set":
+        case "add": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          if (this.data.rewards.op === "set") {
+            reward_clear(tx, object, permission, passport);
+          }
+          const rewards = await (0, import_util2.queryObjectsWithType)(
+            env,
+            this.data.rewards.objects,
+            import_object.ObjectType.Reward,
+            "reward::Reward",
+            false
+          );
+          rewards.forEach((reward) => {
+            reward_add(
+              tx,
+              object,
+              permission,
+              reward.object,
+              reward.type,
+              passport
+            );
+          });
+          break;
+        }
+        case "remove": {
+          if (this.data.rewards.objects.length > MAX_REWARD_COUNT) {
+            (0, import_exception.W_ERROR)(
+              import_exception.WErrors.InvalidParam,
+              `rewards count exceeds maximum limit ${MAX_REWARD_COUNT}`
+            );
+          }
+          const rewardAddrs = await import_local2.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.owner_receive != null && this.object_address) {
+      if (this.data.owner_receive === "recently") {
+        this.data.owner_receive = await (0, import_received.query_received)({
+          object: this.object_address,
+          all_type: true
+        });
+      }
+      await (0, import_util.owner_receive)(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        void 0,
+        (name) => `${import_common.PackageAddress}::repository::${name}`,
+        passport
+      );
+    }
+    if (this.data.um !== void 0) {
+      let um_address = null;
+      if (this.data.um) {
+        um_address = await import_local2.LocalMark.Instance().get_address(this.data.um) || null;
+        if (!um_address) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            "CallRepository_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(tx, object, permission, um_address, passport);
+    }
+    if (!this.permission_address) {
+      const p = (0, import_common2.GetObject)(this.data?.object);
+      await this.new_with_mark(
+        env,
+        tx,
+        import_object.ObjectType.Permission,
+        (0, import_permission2.create)(tx, permission),
+        (0, import_common2.GetObject)(p.permission)
+      );
+    }
+    if (!this.object_address) {
+      await this.new_with_mark(
+        env,
+        tx,
+        import_object.ObjectType.Repository,
+        create(tx, object),
+        (0, import_common2.GetObject)(this.data?.object)
+      );
+    }
+  }
+}
+function create(tx, repository) {
+  (0, import_util.validObjects)([repository]);
+  return tx.moveCall({
+    target: (0, import_common.repositoryFn)("create"),
+    arguments: [(0, import_common.toTxObject)(tx, repository)]
+  });
+}
+function policy_guard(tx, param) {
+  (0, import_util.validObjects)([param.guard]);
+  if (param.id_from_submission != null && !(0, import_common.isValidU8)(param.id_from_submission)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU8,
+      `Id from submission ${param.id_from_submission} is not valid`
+    );
+  }
+  if (param.data_from_submission != null && !(0, import_common.isValidU8)(param.data_from_submission)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidU8,
+      `Data from submission ${param.data_from_submission} is not valid`
+    );
+  }
+  return tx.moveCall({
+    target: (0, import_common.repositoryFn)("policy_guard"),
+    arguments: [
+      (0, import_common.toTxObject)(tx, param.guard),
+      tx.pure.option("u8", param.id_from_submission ?? null),
+      tx.pure.option("u8", param.data_from_submission ?? null)
+    ]
+  });
+}
+function policy(tx, param) {
+  if (typeof param.name === "string" && !(0, import_common.isValidName)(param.name)) {
+    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Policy name ${param.name} is not valid`);
+  }
+  if (typeof param.description === "string" && !(0, import_common.isValidDescription)(param.description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  (0, import_util.validObjects)([
+    param.quote_guard,
+    ...param.write_guard.map((guard) => guard.guard)
+  ]);
+  const idFrom = (0, import_object.parseIdFrom)(param.id_from);
+  const obj = tx.moveCall({
+    target: (0, import_common.repositoryFn)("policy"),
+    arguments: [
+      (0, import_common.toTxString)(tx, param.name),
+      (0, import_common.toTxString)(tx, param.description),
+      tx.pure.u8(idFrom),
+      tx.pure.u8(param.value_type)
+    ]
+  });
+  if (param.quote_guard) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_quote_guard_set"),
+      arguments: [obj, (0, import_common.toTxObject)(tx, param.quote_guard)]
+    });
+  } else if (param.quote_guard === null) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_quote_guard_none"),
+      arguments: [obj]
+    });
+  }
+  if (param.write_guard.length > 0) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_write_guard_set"),
+      arguments: [
+        obj,
+        tx.makeMoveVec({
+          elements: param.write_guard.map(
+            (guard) => policy_guard(tx, guard)
+          ),
+          type: `${import_common.PackageAddress}::repository::PolicyGuard`
+        })
+      ]
+    });
+  }
+  return obj;
+}
+async function data_id_from(tx, repository, policy2, data2, passport) {
+  const idFrom = (0, import_object.parseIdFrom)(policy2.id_from);
+  if (idFrom === import_object.IdFrom.None) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `id_from must be set when id_from is IdFrom.None`
+    );
+  }
+  if (data2.write_guard) {
+    if (!passport) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `passport is required when write_guard is specified`
+      );
+    }
+    if (policy2.write_guard.find(
+      (guard) => guard.guard === data2.write_guard
+    )) {
+      const policyValueType1 = (0, import_common.parseValueType)(policy2.value_type);
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)("data_when_id_from_set_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxString)(tx, policy2.name),
+          tx.pure.address(data2.write_guard),
+          tx.pure.vector(
+            "u8",
+            await (0, import_util.valueToBcsBytes)(policyValueType1, data2.data)
+          ),
+          tx.object.clock(),
+          passport
+        ]
+      });
+    } else {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Write guard ${data2.write_guard} is not in policy ${policy2.name}`
+      );
+    }
+  } else {
+    if (policy2.write_guard.length === 0) {
+      const policyValueType2 = (0, import_common.parseValueType)(policy2.value_type);
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)("data_when_id_from_set"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxString)(tx, policy2.name),
+          tx.pure.vector(
+            "u8",
+            await (0, import_util.valueToBcsBytes)(policyValueType2, data2.data)
+          ),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `specify write guard in policy ${policy2.write_guard.map((guard) => guard.guard)}`
+      );
+    }
+  }
+}
+function um_set(tx, repository, permission, um, passport) {
+  (0, import_util.validObjects)([repository, permission]);
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)(`um_set_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)(`um_set`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxObject)(tx, permission),
+          (0, import_common.toTxObject)(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)(`um_none_with_passport`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxObject)(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ]
+      });
+    } else {
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)(`um_none`),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxObject)(tx, permission),
+          tx.object.mutRegistrar()
+        ]
+      });
+    }
+  }
+}
+async function data(tx, repository, policy2, data2, passport) {
+  (0, import_util.validObjects)([repository]);
+  if (policy2.id_from !== import_object.IdFrom.None) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.InvalidParam,
+      `id_from must be IdFrom.None when items is provided`
+    );
+  }
+  const noGuardItems = [];
+  const regularGuards = [];
+  const mixedItems = [];
+  for (const item of data2) {
+    if (!item.write_guard) {
+      if (policy2.write_guard.length === 0) {
+        noGuardItems.push(item);
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `specify write guard in policy ${policy2.write_guard.map((guard) => guard.guard)}`
+        );
+      }
+    } else {
+      const guard = item.write_guard;
+      const policyGuard = policy2.write_guard.find(
+        (g) => g.guard === guard
+      );
+      if (!policyGuard) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Guard ${guard} not found in policy ${policy2.write_guard.map((guard2) => guard2.guard)}`
+        );
+      }
+      const hasSubmissionSettings = policyGuard.id_from_submission !== void 0;
+      if (hasSubmissionSettings) {
+        if (item.data.length > 0) {
+          const lastItem = item.data[item.data.length - 1];
+          const existingIndex = mixedItems.findIndex(
+            (item2) => item2.guard === guard
+          );
+          if (existingIndex >= 0) {
+            mixedItems[existingIndex] = {
+              guard,
+              id: lastItem.id,
+              data: lastItem.data
+            };
+          } else {
+            mixedItems.push({
+              guard,
+              id: lastItem.id,
+              data: lastItem.data
+            });
+          }
+        }
+      } else {
+        const existingGuard = regularGuards.find(
+          (g) => g.guard === guard
+        );
+        if (existingGuard) {
+          existingGuard.items.push(item);
+        } else {
+          regularGuards.push({ guard, items: [item] });
+        }
+      }
+    }
+  }
+  if (noGuardItems.length > 0) {
+    const policyValueType3 = (0, import_common.parseValueType)(policy2.value_type);
+    const ids = noGuardItems.flatMap(
+      (item) => item.data.map((keyData) => keyData.id)
+    );
+    const dataBytes = await Promise.all(
+      noGuardItems.flatMap((item) => item.data).map(
+        async (keyData) => await (0, import_util.valueToBcsBytes)(policyValueType3, keyData.data)
+      )
+    );
+    if (ids.length !== dataBytes.length) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Id and data arrays must have the same length`
+      );
+    }
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("id_data"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxString)(tx, policy2.name),
+        tx.pure.vector("address", ids),
+        tx.makeMoveVec({
+          elements: dataBytes.map((arr) => tx.pure.vector("u8", arr)),
+          type: "vector<u8>"
+        })
+      ]
+    });
+  }
+  if (mixedItems.length > 0) {
+    if (!passport) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "Guard specified but no passport provided"
+      );
+    }
+    const policyValueType4 = (0, import_common.parseValueType)(policy2.value_type);
+    const ids = mixedItems.map((item) => item.id);
+    const dataBytes = await Promise.all(
+      mixedItems.map(
+        async (item) => await (0, import_util.valueToBcsBytes)(policyValueType4, item.data)
+      )
+    );
+    const guards = mixedItems.map((item) => item.guard);
+    if (ids.length !== dataBytes.length || ids.length !== guards.length) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Id, data, and guard arrays must have the same length`
+      );
+    }
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("id_data_mixed_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxString)(tx, policy2.name),
+        tx.pure.vector("address", guards),
+        tx.pure.vector("address", ids),
+        tx.makeMoveVec({
+          elements: dataBytes.map((arr) => tx.pure.vector("u8", arr)),
+          type: "vector<u8>"
+        }),
+        (0, import_common.toTxObject)(tx, passport)
+      ]
+    });
+  }
+  for (const { guard, items } of regularGuards) {
+    if (!passport) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        "Guard specified but no passport provided"
+      );
+    }
+    const policyValueType5 = (0, import_common.parseValueType)(policy2.value_type);
+    const keyDataItems = items.flatMap((item) => item.data);
+    const ids = keyDataItems.map((keyData) => keyData.id);
+    const dataBytes = await Promise.all(
+      keyDataItems.map(
+        async (keyData) => await (0, import_util.valueToBcsBytes)(policyValueType5, keyData.data)
+      )
+    );
+    if (ids.length !== dataBytes.length) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `Id and data arrays must have the same length for guard ${guard}`
+      );
+    }
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("id_data_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxString)(tx, policy2.name),
+        tx.pure.address(guard),
+        tx.pure.vector("address", ids),
+        tx.makeMoveVec({
+          elements: dataBytes.map((arr) => tx.pure.vector("u8", arr)),
+          type: "vector<u8>"
+        }),
+        (0, import_common.toTxObject)(tx, passport)
+      ]
+    });
+  }
+}
+function newRepository(tx, permission, description, passport) {
+  (0, import_util.validObjects)([permission, passport]);
+  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: (0, import_common.repositoryFn)("new_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    return tx.moveCall({
+      target: (0, import_common.repositoryFn)("new"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function description_set(tx, repository, permission, description, passport) {
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (typeof description === "string" && !(0, import_common.isValidDescription)(description)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidDescription,
+      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("description_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        (0, import_common.toTxString)(tx, description)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("description_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxString)(tx, description)
+      ]
+    });
+  }
+}
+function policy_add(tx, repository, permission, policies, passport) {
+  if (policies.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.makeMoveVec({
+          elements: policies.map((p) => policy(tx, p)),
+          type: `${import_common.PackageAddress}::repository::PolicyRule`
+        }),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.makeMoveVec({
+          elements: policies.map((p) => policy(tx, p)),
+          type: `${import_common.PackageAddress}::repository::PolicyRule`
+        }),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function policy_set(tx, repository, permission, policies, passport) {
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_set_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.makeMoveVec({
+          elements: policies.map((p) => policy(tx, p)),
+          type: `${import_common.PackageAddress}::repository::PolicyRule`
+        }),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_set"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.makeMoveVec({
+          elements: policies.map((p) => policy(tx, p)),
+          type: `${import_common.PackageAddress}::repository::PolicyRule`
+        }),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ]
+    });
+  }
+}
+function policy_remove(tx, repository, permission, policies, passport) {
+  if (policies.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("string", policies),
+        tx.object.mutRegistrar()
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("string", policies),
+        tx.object.mutRegistrar()
+      ]
+    });
+  }
+}
+function policy_clear(tx, repository, permission, passport) {
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("policy_clear"),
+      arguments: [(0, import_common.toTxObject)(tx, repository), (0, import_common.toTxObject)(tx, permission)]
+    });
+  }
+}
+function reward_add(tx, repository, permission, reward, reward_type, passport) {
+  (0, import_util.validObjects)([repository, permission, passport, reward]);
+  if (!(0, import_common.IsValidArgType)(reward_type)) {
+    (0, import_exception.W_ERROR)(
+      import_exception.WErrors.IsValidArgType,
+      `Reward type ${reward_type} is not valid`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_add_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.object(reward)
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_add"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.object(reward)
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function reward_remove(tx, repository, permission, rewards, passport) {
+  if (rewards.length === 0) {
+    return;
+  }
+  (0, import_util.validObjects)([repository, permission, passport, ...rewards]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_remove_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport),
+        tx.pure.vector("address", rewards)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_remove"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        tx.pure.vector("address", rewards)
+      ]
+    });
+  }
+}
+function reward_clear(tx, repository, permission, passport) {
+  (0, import_util.validObjects)([repository, permission, passport]);
+  if (passport) {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_clear_with_passport"),
+      arguments: [
+        (0, import_common.toTxObject)(tx, repository),
+        (0, import_common.toTxObject)(tx, permission),
+        (0, import_common.toTxObject)(tx, passport)
+      ]
+    });
+  } else {
+    tx.moveCall({
+      target: (0, import_common.repositoryFn)("reward_clear"),
+      arguments: [(0, import_common.toTxObject)(tx, repository), (0, import_common.toTxObject)(tx, permission)]
+    });
+  }
+}
+async function data_remove(tx, repository, policy2, param, passport) {
+  (0, import_util.validObjects)([repository]);
+  if ("items" in param) {
+    if (policy2.id_from !== import_object.IdFrom.None) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `id_from must be IdFrom.None when items is provided`
+      );
+    }
+    const noGuardItems = [];
+    const regularGuards = [];
+    const mixedItems = [];
+    for (const item of param.items) {
+      if (!item.write_guard) {
+        if (policy2.write_guard.length === 0) {
+          noGuardItems.push(...item.id);
+        } else {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `specify write guard in policy ${policy2.write_guard.map((guard) => guard.guard)}`
+          );
+        }
+      } else {
+        const guard = item.write_guard;
+        const policyGuard = policy2.write_guard.find(
+          (g) => g.guard === guard
+        );
+        if (!policyGuard) {
+          (0, import_exception.W_ERROR)(
+            import_exception.WErrors.InvalidParam,
+            `Guard ${guard} not found in policy ${policy2.write_guard.map((guard2) => guard2.guard)}`
+          );
+        }
+        const hasSubmissionSettings = policyGuard.id_from_submission !== void 0;
+        if (hasSubmissionSettings) {
+          mixedItems.push(guard);
+        } else {
+          const existingGuard = regularGuards.find(
+            (g) => g.guard === guard
+          );
+          if (existingGuard) {
+            existingGuard.id.push(...item.id);
+          } else {
+            regularGuards.push({
+              guard,
+              id: [...item.id]
+            });
+          }
+        }
+      }
+    }
+    if (noGuardItems.length > 0) {
+      if (policy2.write_guard.length !== 0) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `specify write guard in policy ${policy2.write_guard.map((guard) => guard.guard)}`
+        );
+      }
+      const uniqueIds = [...new Set(noGuardItems)];
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)("id_data_remove"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxString)(tx, policy2.name),
+          tx.pure.vector("address", uniqueIds)
+        ]
+      });
+    }
+    if (mixedItems.length > 0) {
+      if (!passport) {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          "Guard specified but no passport provided"
+        );
+      }
+      const uniqueIds = [...new Set(mixedItems)];
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)("id_data_mixed_remove_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxString)(tx, policy2.name),
+          tx.pure.vector("address", uniqueIds),
+          (0, import_common.toTxObject)(tx, passport)
+        ]
+      });
+    }
+    for (const { guard, id } of regularGuards) {
+      const uniqueIds = [...new Set(id)];
+      tx.moveCall({
+        target: (0, import_common.repositoryFn)("id_data_remove_with_passport"),
+        arguments: [
+          (0, import_common.toTxObject)(tx, repository),
+          (0, import_common.toTxString)(tx, policy2.name),
+          tx.pure.address(guard),
+          tx.pure.vector("address", uniqueIds),
+          (0, import_common.toTxObject)(tx, passport)
+        ]
+      });
+    }
+  } else {
+    const guard = param.write_guard;
+    if (policy2.id_from === import_object.IdFrom.None) {
+      (0, import_exception.W_ERROR)(
+        import_exception.WErrors.InvalidParam,
+        `id_from must be set when id_from is IdFrom.None`
+      );
+    }
+    if (guard) {
+      if (policy2.write_guard.find((g) => g.guard === guard)) {
+        tx.moveCall({
+          target: (0, import_common.repositoryFn)(
+            "data_remove_when_id_from_set_with_passport"
+          ),
+          arguments: [
+            (0, import_common.toTxObject)(tx, repository),
+            (0, import_common.toTxString)(tx, policy2.name),
+            tx.pure.address(guard),
+            tx.object.clock(),
+            (0, import_common.toTxObject)(tx, passport)
+          ]
+        });
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `Write guard ${guard} is not in policy ${policy2.write_guard.map((guard2) => guard2.guard)}`
+        );
+      }
+    } else {
+      if (policy2.write_guard.length === 0) {
+        tx.moveCall({
+          target: (0, import_common.repositoryFn)("data_remove_when_id_from_set"),
+          arguments: [
+            (0, import_common.toTxObject)(tx, repository),
+            (0, import_common.toTxString)(tx, policy2.name),
+            tx.object.clock()
+          ]
+        });
+      } else {
+        (0, import_exception.W_ERROR)(
+          import_exception.WErrors.InvalidParam,
+          `specify write guard in policy ${policy2.write_guard.map((guard2) => guard2.guard)}`
+        );
+      }
+    }
+  }
+}