wowok 2.1.10 → 2.1.13

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

@@ -1,24 +1,9 @@
-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";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+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 { GetObjectExisted, GetObject, GetObjectDescription, } from "../common.js";
 import { LocalMark } from "../local/local.js";
 import { CallBase, getCoinParam } from "./base.js";
 import { BuiltinPermissionIndex, newPermission } from "./permission.js";
@@ -27,848 +12,676 @@ 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)
-      );
-    }
-  }
+// ================================================
+// 数据操作类
+export class CallReward extends CallBase {
+    data;
+    object_address = undefined;
+    permission_address = undefined;
+    new_permission_description = undefined;
+    reward_type = undefined;
+    constructor(data) {
+        super();
+        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); // prepare first.
+        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((g) => g.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);
+        }
+        //@ notice guard_expiration_time 为 null 时，取消设置过期时间
+        if (this.permission_address &&
+            this.data?.guard_expiration_time !== undefined) {
+            add_perm(BuiltinPermissionIndex.REWARD_GUARD_EXPIRATION_TIME_ADD);
+        }
+        if (this.permission_address && this.data?.guard_add != null) {
+            add_perm(BuiltinPermissionIndex.REWARD_GUARD);
+        }
+        //@ notice guard_remove_expired 为 true 时，移除过期守卫
+        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 !== undefined) {
+            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,
+                });
+                // 检查received的类型，如果是ReceivedNormal[]，需要转换为ReceivedBalance
+                if (Array.isArray(received)) {
+                    W_ERROR(WErrors.InvalidParam, "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]");
+                }
+                else {
+                    // 如果是ReceivedBalance类型，直接赋值
+                    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);
+        }
+        //@ notice guard_expiration_time 为 null 时，取消设置过期时间
+        if (this.data?.guard_expiration_time !== undefined) {
+            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);
+        }
+        // 处理 um
+        if (this.data.um !== undefined) {
+            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]
-  });
+// ================================================
+// 常量定义
+export const MAX_GUARD_COUNT = 200;
+export const MAX_RECORD_COUNT = 5200;
+export 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]
-  });
+    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 undefined;
 }
-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 {
+export 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("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]
+        target: rewardFn("claim"),
+        arguments: [
+            toTxObject(tx, reward),
+            toTxObject(tx, passport),
+            toTxObject(tx, guard),
+            tx.object.clock(),
+        ],
+        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]
-    });
-  }
+// ================================================
+// 构造函数和设置函数
+export 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 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]
-    });
-  }
+export 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 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]
-    });
-  }
+export 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}`);
+    }
+    // 构建 RewardGuard 对象
+    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 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]
-    });
-  }
+export 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],
+        });
+    }
 }
-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]
-    });
-  }
+export 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);
+    //console.dir(c, { depth: null });
+    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 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) {
+export 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) {
-      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]
-      });
+        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],
+        });
+    }
+}
+export 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}`);
     }
-  } 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]
-      });
+        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],
+        });
+    }
+}
+export 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
-};
+//# sourceMappingURL=reward.js.map