wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,874 @@
+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 {
+  toTxObject,
+  toTxString,
+  isValidDescription,
+  MAX_DESCRIPTION_LENGTH,
+  isValidU8,
+  PackageAddress,
+  isValidU64,
+  IsValidArgType,
+  rewardFn
+} from "../common.js";
+import { W_ERROR, WErrors } from "../exception.js";
+import { parseObjectType, validObjects } from "../util.js";
+import {
+  GetObjectExisted,
+  GetObject,
+  GetObjectDescription
+} from "../common.js";
+import { LocalMark } from "../local/local.js";
+import { CallBase, getCoinParam } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { owner_receive } from "../util.js";
+import { AmountType, ObjectType } from "../query/object.js";
+import { GetAccountOrMark_Address } from "../local/index.js";
+import { create as permissionCreate } from "./permission.js";
+import { query_received } from "../query/received.js";
+class CallReward extends CallBase {
+  constructor(data) {
+    super();
+    __publicField(this, "data");
+    __publicField(this, "object_address");
+    __publicField(this, "permission_address");
+    __publicField(this, "new_permission_description");
+    __publicField(this, "reward_type");
+    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.Reward,
+        this.object_address
+      );
+      if (!this.content)
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallReward_Data.data.object:" + this.object_address
+        );
+      this.permission_address = this.content.permission;
+      this.reward_type = parseObjectType(
+        this.content.type_raw,
+        "reward::Reward"
+      );
+      if (!this.permission_address) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "CallReward_Data.data.object.permission is empty"
+        );
+      }
+      if (!IsValidArgType(this.reward_type)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallReward_Data.data.object.type_parameter is empty"
+        );
+      }
+    } else {
+      const n = GetObject(
+        this.data.object
+      );
+      this.permission_address = await GetObjectExisted(n?.permission);
+      this.new_permission_description = GetObjectDescription(
+        n?.permission
+      );
+      this.reward_type = n?.type_parameter;
+      if (!IsValidArgType(this.reward_type)) {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallReward_Data.data.object.type invalid"
+        );
+      }
+    }
+  }
+  async call(env) {
+    await this.prepare(env);
+    const guards = [];
+    const perms = [];
+    const content = this.content;
+    const add_perm = (index) => {
+      if (this.permission_address && !perms.includes(index)) {
+        perms.push(index);
+      }
+    };
+    if (this.permission_address && !this.object_address) {
+      add_perm(BuiltinPermissionIndex.REWARD_NEW);
+    }
+    if (this.data?.claim != null) {
+      const g = await LocalMark.Instance().get_address(this.data.claim);
+      if (g) {
+        if (content) {
+          const f = content.guards.find((guard) => guard.guard === g);
+          if (!f) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `Guard ${g} is not fount in reward guards ${content.guards.map((g2) => g2.guard)}`
+            );
+          }
+          if (f?.amount?.type === AmountType.Fixed && BigInt(f?.amount?.value) > BigInt(content.balance)) {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `Guard ${g} amount ${f?.amount?.value} is greater than reward balance ${content.balance}`
+            );
+          }
+        }
+        this.data.claim = g;
+        guards.push(g);
+      } else {
+        W_ERROR(
+          WErrors.IsValidArgType,
+          "CallReward_Data.data.claim is not a valid guard address"
+        );
+      }
+    }
+    if (this.permission_address && this.data?.description != null && this.object_address) {
+      add_perm(BuiltinPermissionIndex.REWARD_DESCRIPTION);
+    }
+    if (this.permission_address && this.data?.coin_add != null) {
+      add_perm(BuiltinPermissionIndex.REWARD_COIN_ADD);
+    }
+    if (this.permission_address && this.data?.receive != null) {
+      add_perm(BuiltinPermissionIndex.REWARD_RECEIVE);
+    }
+    if (this.permission_address && this.data?.guard_expiration_time !== void 0) {
+      add_perm(BuiltinPermissionIndex.REWARD_GUARD_EXPIRATION_TIME_ADD);
+    }
+    if (this.permission_address && this.data?.guard_add != null) {
+      add_perm(BuiltinPermissionIndex.REWARD_GUARD);
+    }
+    if (this.permission_address && this.data?.guard_remove_expired) {
+      add_perm(BuiltinPermissionIndex.DEMAND_GUARD);
+    }
+    if (this.permission_address && this.data?.owner_receive != null) {
+      add_perm(BuiltinPermissionIndex.REWARD_OWNER_RECEIVE);
+    }
+    if (this.permission_address && this.data?.um !== void 0) {
+      add_perm(BuiltinPermissionIndex.REWARD_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;
+    const content = this.content;
+    if (!this.object_address) {
+      if (!permission) {
+        permission = newPermission(
+          tx,
+          this.new_permission_description ?? ""
+        );
+      }
+      if (permission && this.reward_type) {
+        object = newReward(
+          tx,
+          this.reward_type,
+          toTxObject(tx, permission),
+          this.data?.description ?? "",
+          passport
+        );
+      }
+    }
+    if (!object || !permission || !this.reward_type) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        "CallReward_Data.data.object:" + this.object_address
+      );
+    }
+    if (this.data?.claim != null) {
+      claim(tx, object, this.reward_type, this.data.claim, passport);
+    }
+    if (this.data?.description != null && this.object_address) {
+      description_set(
+        tx,
+        object,
+        this.reward_type,
+        permission,
+        this.data.description,
+        passport
+      );
+    }
+    if (this.data?.coin_add != null) {
+      await coin_add(
+        env,
+        tx,
+        object,
+        this.reward_type,
+        permission,
+        this.data.coin_add,
+        passport
+      );
+    }
+    if (this.data?.receive != null && this.object_address) {
+      if (this.data.receive === "recently") {
+        const received = await query_received({
+          object: this.object_address,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+        if (Array.isArray(received)) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]"
+          );
+        } else {
+          this.data.receive = received;
+        }
+      }
+      if (typeof this.data.receive === "object" && "received" in this.data.receive && this.data.receive.received?.length > 0) {
+        if (this.data.receive?.token_type !== this.reward_type) {
+          W_ERROR(
+            WErrors.InvalidParam,
+            "CallReward_Data.data.receive.token_type:" + this.data.receive?.token_type
+          );
+        }
+        for (const item of this.data.receive.received) {
+          const [r, p] = await Promise.all([
+            LocalMark.Instance().get_address(item.id),
+            LocalMark.Instance().get_address(item.payment)
+          ]);
+          if (p && r) {
+            receive(
+              tx,
+              object,
+              this.reward_type,
+              permission,
+              toTxObject(tx, r),
+              toTxObject(tx, p),
+              passport
+            );
+          } else {
+            W_ERROR(
+              WErrors.InvalidParam,
+              `Payment object ${item.payment} or received object ${item.id} is not valid`
+            );
+          }
+        }
+      }
+    }
+    if (this.data?.guard_add != null) {
+      if (content && content.guard_not_added_expiration_time != null && BigInt(content.guard_not_added_expiration_time) >= BigInt(Date.now())) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `The time lock does not allow the addition of new guards. ${this.data.guard_expiration_time}  is before current time ${Date.now()}`
+        );
+      }
+      if (this.data.guard_add.length > MAX_GUARD_COUNT) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `guard_add count exceeds maximum limit ${MAX_GUARD_COUNT}`
+        );
+      }
+      await Promise.all(
+        this.data.guard_add.map(
+          (guard) => guard_add(
+            tx,
+            object,
+            this.reward_type,
+            permission,
+            guard,
+            passport
+          )
+        )
+      );
+    }
+    if (this.data.guard_remove_expired) {
+      guard_remove_expired(
+        tx,
+        object,
+        this.reward_type,
+        permission,
+        passport
+      );
+    }
+    if (this.data?.guard_expiration_time !== void 0) {
+      guard_expiration_time_add(
+        tx,
+        object,
+        this.reward_type,
+        permission,
+        this.data.guard_expiration_time,
+        passport
+      );
+    }
+    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,
+          network: env.network,
+          no_cache: env.no_cache
+        });
+      }
+      await owner_receive(
+        tx,
+        object,
+        permission,
+        this.data.owner_receive,
+        this.reward_type,
+        (name) => `${PackageAddress}::reward::${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,
+            "CallReward_Data.data.um:" + this.data.um
+          );
+        }
+      }
+      um_set(
+        tx,
+        object,
+        this.reward_type,
+        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.Reward,
+        create(tx, object, this.reward_type),
+        GetObject(this.data?.object)
+      );
+    }
+  }
+}
+const MAX_GUARD_COUNT = 200;
+const MAX_RECORD_COUNT = 5200;
+function create(tx, reward, reward_type) {
+  validObjects([reward]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `Create reward type ${reward_type} is not valid`
+    );
+  }
+  return tx.moveCall({
+    target: rewardFn("create"),
+    arguments: [toTxObject(tx, reward)],
+    typeArguments: [reward_type]
+  });
+}
+async function reward_guard(tx, param) {
+  const g = await LocalMark.Instance().get_address(param.guard);
+  if (g) {
+    param.guard = g;
+  } else {
+    W_ERROR(WErrors.InvalidParam, `Guard ${param.guard} is not valid`);
+  }
+  validObjects([param.guard]);
+  if ("GuardIdentifier" in param.recipient) {
+    const guardId = param.recipient.GuardIdentifier;
+    if (typeof guardId !== "number") {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Recipient GuardIdentifier ${guardId} must be a number`
+      );
+    }
+    if (!isValidU8(guardId)) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Recipient GuardIdentifier ${guardId} must be a valid u8`
+      );
+    }
+    if (param.amount.type === AmountType.GuardU64Identifier) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount GuardU64Identifier value must be a number"
+        );
+      }
+      if (!isValidU8(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount GuardU64Identifier ${param.amount.value} must be a valid u8`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_u8_u8"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.u8(guardId),
+          tx.pure.u8(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    } else if (param.amount.type === AmountType.Fixed) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount Fixed value must be a number"
+        );
+      }
+      if (!isValidU64(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount Fixed ${param.amount.value} must be a valid u64`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_u8_u64"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.u8(guardId),
+          tx.pure.u64(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    }
+  } else if ("Entity" in param.recipient) {
+    const entity = param.recipient.Entity;
+    const r = await GetAccountOrMark_Address(entity);
+    if (!r) {
+      W_ERROR(
+        WErrors.InvalidParam,
+        `Recipient Entity ${entity} must be a valid address`
+      );
+    }
+    if (param.amount.type === AmountType.GuardU64Identifier) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount GuardU64Identifier value must be a number"
+        );
+      }
+      if (!isValidU8(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount GuardU64Identifier ${param.amount.value} must be a valid u8`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_entity_u8"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.address(r),
+          tx.pure.u8(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    } else if (param.amount.type === AmountType.Fixed) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount Fixed value must be a number"
+        );
+      }
+      if (!isValidU64(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount Fixed ${param.amount.value} must be a valid u64`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_entity_u64"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.address(r),
+          tx.pure.u64(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    }
+  } else if ("Signer" in param.recipient) {
+    if (param.amount.type === AmountType.GuardU64Identifier) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount GuardU64Identifier value must be a number"
+        );
+      }
+      if (!isValidU8(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount GuardU64Identifier ${param.amount.value} must be a valid u8`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_signer_u8"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.u8(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    } else if (param.amount.type === AmountType.Fixed) {
+      if (typeof param.amount.value !== "number") {
+        W_ERROR(
+          WErrors.InvalidParam,
+          "Amount Fixed value must be a number"
+        );
+      }
+      if (!isValidU64(param.amount.value)) {
+        W_ERROR(
+          WErrors.InvalidParam,
+          `Amount Fixed ${param.amount.value} must be a valid u64`
+        );
+      }
+      return tx.moveCall({
+        target: rewardFn("guard_signer_u64"),
+        arguments: [
+          toTxObject(tx, param.guard),
+          tx.pure.u64(param.amount.value),
+          tx.pure.option("u64", param.expiration_time ?? null)
+        ]
+      });
+    }
+  }
+  W_ERROR(
+    WErrors.InvalidParam,
+    `Invalid recipient or amount type combination`
+  );
+  return void 0;
+}
+function claim(tx, reward, reward_type, guard, passport) {
+  if (!passport) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      "CallReward_Data.data.claim: passport is required"
+    );
+  }
+  validObjects([reward, passport, guard]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.IsValidArgType, `Invalid reward type ${reward_type}`);
+  }
+  return tx.moveCall({
+    target: rewardFn("claim"),
+    arguments: [
+      toTxObject(tx, reward),
+      toTxObject(tx, passport),
+      toTxObject(tx, guard),
+      tx.object.clock()
+    ],
+    typeArguments: [reward_type]
+  });
+}
+function newReward(tx, reward_type, permission, description, passport) {
+  validObjects([permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: rewardFn("new_with_passport"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    return tx.moveCall({
+      target: rewardFn("new"),
+      arguments: [
+        toTxObject(tx, permission),
+        toTxString(tx, description),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function description_set(tx, reward, reward_type, permission, description, passport) {
+  validObjects([reward, permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (typeof description === "string" && !isValidDescription(description)) {
+    W_ERROR(
+      WErrors.IsValidDescription,
+      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: rewardFn("description_set_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxString(tx, description)
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: rewardFn("description_set"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxString(tx, description)
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+async function guard_add(tx, reward, reward_type, permission, param, passport) {
+  validObjects([reward, permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  const rewardGuardArg = await reward_guard(tx, param);
+  if (!rewardGuardArg) {
+    W_ERROR(
+      WErrors.InvalidParam,
+      `CallReward_Data.data.guard_add ${param} failed`
+    );
+  }
+  if (passport) {
+    tx.moveCall({
+      target: rewardFn("guard_add_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        rewardGuardArg,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: rewardFn("guard_add"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        rewardGuardArg,
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function guard_remove_expired(tx, reward, reward_type, permission, passport) {
+  validObjects([reward, permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: rewardFn("guard_remove_expired_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: rewardFn("guard_remove_expired"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        tx.object.mutRegistrar(),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+async function coin_add(env, tx, reward, reward_type, permission, coin, passport) {
+  validObjects([reward, permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  const c = await getCoinParam(env, tx, coin, reward_type);
+  if (passport) {
+    tx.moveCall({
+      target: rewardFn("coin_add_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        c
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: rewardFn("coin_add"),
+      arguments: [toTxObject(tx, reward), toTxObject(tx, permission), c],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function receive(tx, reward, reward_type, permission, received, payment, passport) {
+  validObjects([reward, permission, passport, received, payment]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (passport) {
+    return tx.moveCall({
+      target: rewardFn("receive_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        toTxObject(tx, received),
+        toTxObject(tx, payment)
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    return tx.moveCall({
+      target: rewardFn("receive"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, received),
+        toTxObject(tx, payment)
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function guard_expiration_time_add(tx, reward, reward_type, permission, time, passport) {
+  validObjects([reward, permission, passport]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (passport) {
+    tx.moveCall({
+      target: rewardFn("guard_expiration_time_add_with_passport"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        toTxObject(tx, passport),
+        tx.pure.option("u64", time ?? null),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  } else {
+    tx.moveCall({
+      target: rewardFn("guard_expiration_time_add"),
+      arguments: [
+        toTxObject(tx, reward),
+        toTxObject(tx, permission),
+        tx.pure.option("u64", time ?? null),
+        tx.object.clock()
+      ],
+      typeArguments: [reward_type]
+    });
+  }
+}
+function um_set(tx, reward, reward_type, permission, um, passport) {
+  validObjects([reward, permission]);
+  if (!IsValidArgType(reward_type)) {
+    W_ERROR(WErrors.InvalidParam, `Invalid reward type ${reward_type}`);
+  }
+  if (um) {
+    if (passport) {
+      tx.moveCall({
+        target: rewardFn(`um_set_with_passport`),
+        arguments: [
+          toTxObject(tx, reward),
+          toTxObject(tx, permission),
+          passport,
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [reward_type]
+      });
+    } else {
+      tx.moveCall({
+        target: rewardFn(`um_set`),
+        arguments: [
+          toTxObject(tx, reward),
+          toTxObject(tx, permission),
+          toTxObject(tx, um),
+          tx.object.mutRegistrar(),
+          tx.object.clock()
+        ],
+        typeArguments: [reward_type]
+      });
+    }
+  } else {
+    if (passport) {
+      tx.moveCall({
+        target: rewardFn(`um_none_with_passport`),
+        arguments: [
+          toTxObject(tx, reward),
+          toTxObject(tx, permission),
+          passport,
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [reward_type]
+      });
+    } else {
+      tx.moveCall({
+        target: rewardFn(`um_none`),
+        arguments: [
+          toTxObject(tx, reward),
+          toTxObject(tx, permission),
+          tx.object.mutRegistrar()
+        ],
+        typeArguments: [reward_type]
+      });
+    }
+  }
+}
+export {
+  CallReward,
+  MAX_GUARD_COUNT,
+  MAX_RECORD_COUNT,
+  claim,
+  coin_add,
+  create,
+  description_set,
+  guard_add,
+  guard_expiration_time_add,
+  guard_remove_expired,
+  newReward,
+  receive,
+  um_set
+};