wowok 2.1.10 → 2.1.13

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

@@ -1,20 +1,6 @@
-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,
-  isValidU64,
-  PackageAddress,
-  IsValidArgType,
-  GetObjectExisted,
-  GetObject,
-  GetObjectDescription,
-  isValidU8,
-  treasuryFn
-} from "../common.js";
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+import { toTxObject, toTxString, isValidDescription, MAX_DESCRIPTION_LENGTH, isValidU64, PackageAddress, IsValidArgType, GetObjectExisted, GetObject, GetObjectDescription, isValidU8, treasuryFn, } from "../common.js";
 import { W_ERROR, WErrors } from "../exception.js";
 import { ObjectType } from "../query/object.js";
 import { owner_receive, parseObjectType, validObjects } from "../util.js";
@@ -25,1162 +11,866 @@ import { LocalMark } from "../local/local.js";
 import { create as permissionCreate } from "./permission.js";
 import { paymentInfo } from "./payment.js";
 import { query_received } from "../query/received.js";
-class CallTreasury extends CallBase {
-  constructor(data) {
-    super();
-    __publicField(this, "data");
-    __publicField(this, "object_address");
-    __publicField(this, "permission_address");
-    __publicField(this, "new_permission_description");
-    __publicField(this, "parameter_type");
-    this.data = data;
-  }
-  async prepare(env) {
-    await super.prepare(env);
-    if (!this.object_address) {
-      this.object_address = await GetObjectExisted(this.data?.object);
+export class CallTreasury extends CallBase {
+    data;
+    object_address = undefined;
+    permission_address = undefined;
+    new_permission_description = undefined;
+    parameter_type = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
     }
-    if (this.object_address) {
-      await this.update_content(
-        env,
-        ObjectType.Treasury,
-        this.object_address
-      );
-      if (!this.content)
-        W_ERROR(
-          WErrors.InvalidParam,
-          "CallTreasury_Data.data.object:" + this.object_address
-        );
-      this.permission_address = this.content.permission;
-      this.parameter_type = parseObjectType(
-        this.content.type_raw,
-        "treasury::Treasury"
-      );
-      if (!this.permission_address) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          "CallTreasury_Data.data.object.permission is empty"
-        );
-      }
-      if (!IsValidArgType(this.parameter_type)) {
-        W_ERROR(
-          WErrors.IsValidArgType,
-          "CallTreasury_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.parameter_type = n?.type_parameter;
-      if (!IsValidArgType(this.parameter_type)) {
-        W_ERROR(
-          WErrors.IsValidArgType,
-          "CallTreasury_Data.data.object.type_parameter invalid"
-        );
-      }
-    }
-  }
-  async call(env) {
-    await this.prepare(env);
-    const guards = [];
-    const perms = [];
-    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(BuiltinPermissionIndex.TREASURY_NEW);
-    }
-    if (this.permission_address && this.data?.description != null && this.object_address) {
-      add_perm(BuiltinPermissionIndex.TREASURY_DESCRIPTION);
-    }
-    if (this.permission_address && this.data?.receive != null) {
-      add_perm(BuiltinPermissionIndex.TREASURY_RECEIVE);
+    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.Treasury, this.object_address);
+            if (!this.content)
+                W_ERROR(WErrors.InvalidParam, "CallTreasury_Data.data.object:" + this.object_address);
+            this.permission_address = this.content.permission;
+            this.parameter_type = parseObjectType(this.content.type_raw, "treasury::Treasury");
+            if (!this.permission_address) {
+                W_ERROR(WErrors.InvalidParam, "CallTreasury_Data.data.object.permission is empty");
+            }
+            if (!IsValidArgType(this.parameter_type)) {
+                W_ERROR(WErrors.IsValidArgType, "CallTreasury_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.parameter_type = n?.type_parameter;
+            if (!IsValidArgType(this.parameter_type)) {
+                W_ERROR(WErrors.IsValidArgType, "CallTreasury_Data.data.object.type_parameter invalid");
+            }
+        }
     }
-    if (this.data?.deposit != null) {
-      if (this.data.deposit.by_external_deposit_guard) {
-        const guard = await LocalMark.Instance().get_address(
-          this.data.deposit.by_external_deposit_guard
-        );
-        if (guard) {
-          add_guard(guard);
-          this.data.deposit.by_external_deposit_guard = guard;
-        } else {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `external_deposit_guard ${this.data.deposit.by_external_deposit_guard} not found`
-          );
+    async call(env) {
+        await this.prepare(env); // prepare first.
+        const guards = [];
+        const perms = [];
+        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(BuiltinPermissionIndex.TREASURY_NEW);
+        }
+        if (this.permission_address &&
+            this.data?.description != null &&
+            this.object_address) {
+            add_perm(BuiltinPermissionIndex.TREASURY_DESCRIPTION);
+        }
+        if (this.permission_address && this.data?.receive != null) {
+            add_perm(BuiltinPermissionIndex.TREASURY_RECEIVE);
+        }
+        if (this.data?.deposit != null) {
+            if (this.data.deposit.by_external_deposit_guard) {
+                const guard = await LocalMark.Instance().get_address(this.data.deposit.by_external_deposit_guard);
+                if (guard) {
+                    add_guard(guard);
+                    this.data.deposit.by_external_deposit_guard = guard;
+                }
+                else {
+                    W_ERROR(WErrors.InvalidParam, `external_deposit_guard ${this.data.deposit.by_external_deposit_guard} not found`);
+                }
+            }
+            else {
+                if (this.permission_address) {
+                    add_perm(BuiltinPermissionIndex.TREASURY_DEPOSIT);
+                }
+            }
+        }
+        if (this.data?.withdraw != null) {
+            const withdraw = this.data.withdraw;
+            if (withdraw && withdraw.amount) {
+                if ("fixed" in withdraw.amount) {
+                    if (this.permission_address) {
+                        add_perm(BuiltinPermissionIndex.TREASURY_WITHDRAW);
+                    }
+                }
+                else if ("by_external_withdraw_guard" in withdraw.amount) {
+                    const guard = await LocalMark.Instance().get_address(withdraw.amount.by_external_withdraw_guard);
+                    if (guard) {
+                        withdraw.amount.by_external_withdraw_guard = guard;
+                        add_guard(guard);
+                    }
+                    else {
+                        W_ERROR(WErrors.InvalidParam, `by_external_withdraw_guard ${withdraw.amount.by_external_withdraw_guard} not found`);
+                    }
+                }
+            }
         }
-      } else {
-        if (this.permission_address) {
-          add_perm(BuiltinPermissionIndex.TREASURY_DEPOSIT);
+        if (this.permission_address &&
+            this.data?.external_deposit_guard != null) {
+            add_perm(BuiltinPermissionIndex.TREASURY_EXTERNAL_DEPOSIT_GUARD);
         }
-      }
+        if (this.permission_address &&
+            this.data?.external_withdraw_guard != null) {
+            add_perm(BuiltinPermissionIndex.TREASURY_EXTERNAL_WITHDRAW_GUARD);
+        }
+        if (this.permission_address && this.data?.owner_receive != null) {
+            add_perm(BuiltinPermissionIndex.TREASURY_OWNER_RECEIVE);
+        }
+        if (this.permission_address && this.data?.um !== undefined) {
+            add_perm(BuiltinPermissionIndex.TREASURY_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);
     }
-    if (this.data?.withdraw != null) {
-      const withdraw2 = this.data.withdraw;
-      if (withdraw2 && withdraw2.amount) {
-        if ("fixed" in withdraw2.amount) {
-          if (this.permission_address) {
-            add_perm(BuiltinPermissionIndex.TREASURY_WITHDRAW);
-          }
-        } else if ("by_external_withdraw_guard" in withdraw2.amount) {
-          const guard = await LocalMark.Instance().get_address(
-            withdraw2.amount.by_external_withdraw_guard
-          );
-          if (guard) {
-            withdraw2.amount.by_external_withdraw_guard = guard;
-            add_guard(guard);
-          } else {
-            W_ERROR(
-              WErrors.InvalidParam,
-              `by_external_withdraw_guard ${withdraw2.amount.by_external_withdraw_guard} not found`
-            );
-          }
+    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.parameter_type) {
+                object = newTreasury(tx, this.parameter_type, permission, this.data?.description ?? "", passport);
+            }
+        }
+        if (!object || !permission) {
+            W_ERROR(WErrors.InvalidParam, "CallTreasury_Data.data.object:" + this.object_address);
+        }
+        if (this.data.description != null && !this.object_address) {
+            description_set(tx, object, this.parameter_type, permission, this.data.description, 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.parameter_type) {
+                    W_ERROR(WErrors.InvalidParam, `token_type ${this.data.receive.token_type} is not equal to parameter_type ${this.parameter_type}`);
+                }
+                for (const item of this.data.receive.received) {
+                    const [received_object, payment_object] = await Promise.all([
+                        LocalMark.Instance().get_address(item.id),
+                        LocalMark.Instance().get_address(item.payment),
+                    ]);
+                    if (received_object && payment_object) {
+                        receive(tx, object, this.parameter_type, permission, received_object, payment_object, passport);
+                    }
+                    else {
+                        W_ERROR(WErrors.IsValidArgType, `Receive object ${item.id} or payment object ${item.payment} not found`);
+                    }
+                }
+            }
+        }
+        if (this.data.deposit != null) {
+            if (this.data.deposit.by_external_deposit_guard) {
+                if (!passport) {
+                    W_ERROR(WErrors.InvalidParam, "Passport is required for external deposit");
+                }
+                await this.new_with_mark(env, tx, ObjectType.Payment, await external_deposit(env, tx, object, this.parameter_type, passport, this.data.deposit.by_external_deposit_guard, this.data.deposit.coin, this.data.deposit.payment_info), this.data.deposit.namedNewPayment);
+            }
+            else {
+                await this.new_with_mark(env, tx, ObjectType.Payment, await deposit(env, tx, object, this.parameter_type, permission, this.data.deposit.coin, this.data.deposit.payment_info, passport), this.data.deposit.namedNewPayment);
+            }
+        }
+        if (this.data.withdraw != null && this.data.withdraw.amount) {
+            if ("fixed" in this.data.withdraw.amount) {
+                await this.new_with_mark(env, tx, ObjectType.Payment, await withdraw(env, tx, object, this.parameter_type, permission, this.data.withdraw.amount.fixed, this.data.withdraw.recipient, this.data.withdraw.payment_info, passport), this.data.withdraw.namedNewPayment);
+            }
+            else if ("by_external_withdraw_guard" in this.data.withdraw.amount) {
+                if (!passport) {
+                    W_ERROR(WErrors.InvalidParam, "Passport is required for external withdraw");
+                }
+                await this.new_with_mark(env, tx, ObjectType.Payment, await external_withdraw(env, tx, object, this.parameter_type, passport, this.data.withdraw.amount.by_external_withdraw_guard, this.data.withdraw.recipient, this.data.withdraw.payment_info), this.data.withdraw.namedNewPayment);
+            }
+        }
+        if (this.data.external_deposit_guard != null) {
+            switch (this.data.external_deposit_guard.op) {
+                case "add":
+                case "set": {
+                    if (this.data.external_deposit_guard.op === "set") {
+                        external_deposit_guard_clear(tx, object, this.parameter_type, permission, passport);
+                    }
+                    await external_deposit_guard_add(tx, object, this.parameter_type, permission, this.data.external_deposit_guard.guards, MAX_EXTERNAL_DEPOSIT_GUARD_COUNT -
+                        (content?.external_deposit_guard?.length ?? 0), passport);
+                    break;
+                }
+                case "remove": {
+                    await external_deposit_guard_remove(tx, object, this.parameter_type, permission, this.data.external_deposit_guard.guards, content?.external_deposit_guard?.length ?? 0, passport);
+                    break;
+                }
+                case "clear": {
+                    external_deposit_guard_clear(tx, object, this.parameter_type, permission, passport);
+                    break;
+                }
+            }
+        }
+        if (this.data.external_withdraw_guard != null) {
+            switch (this.data.external_withdraw_guard.op) {
+                case "add":
+                case "set": {
+                    if (this.data.external_withdraw_guard.op === "set") {
+                        external_withdraw_guard_clear(tx, object, this.parameter_type, permission, passport);
+                    }
+                    await external_withdraw_guard_add(tx, object, this.parameter_type, permission, this.data.external_withdraw_guard.guards, MAX_EXTERNAL_WITHDRAW_GUARD_COUNT -
+                        (content?.external_withdraw_guard?.length ?? 0), passport);
+                    break;
+                }
+                case "remove": {
+                    await external_withdraw_guard_remove(tx, object, this.parameter_type, permission, this.data.external_withdraw_guard.guards, content?.external_withdraw_guard?.length ?? 0, passport);
+                    break;
+                }
+                case "clear": {
+                    external_withdraw_guard_clear(tx, object, this.parameter_type, permission, passport);
+                    break;
+                }
+            }
+        }
+        if (this.data.owner_receive != null && this.object_address) {
+            if (this.data.owner_receive === "recently") {
+                this.data.owner_receive = await query_received({
+                    object: this.object_address,
+                    all_type: true,
+                    network: env.network,
+                    no_cache: env.no_cache,
+                });
+            }
+            // owner_receive 中完成地址查询
+            await owner_receive(tx, object, permission, this.data.owner_receive, this.parameter_type, (name) => `${PackageAddress}::treasury::${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, "CallTreasury_Data.data.um:" + this.data.um);
+                }
+            }
+            um_set(tx, object, this.parameter_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.Treasury, create(tx, object, this.parameter_type), GetObject(this.data?.object));
         }
-      }
     }
-    if (this.permission_address && this.data?.external_deposit_guard != null) {
-      add_perm(BuiltinPermissionIndex.TREASURY_EXTERNAL_DEPOSIT_GUARD);
+}
+// ================================================
+// 常量定义
+export const MAX_EXTERNAL_DEPOSIT_GUARD_COUNT = 100;
+export const MAX_EXTERNAL_WITHDRAW_GUARD_COUNT = 200;
+// ================================================
+// 构造函数和设置函数
+export function newTreasury(tx, treasury_type, permission, description, passport) {
+    validObjects([permission, passport]);
+    if (typeof description === "string" && !isValidDescription(description)) {
+        W_ERROR(WErrors.IsValidDescription, `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (this.permission_address && this.data?.external_withdraw_guard != null) {
-      add_perm(BuiltinPermissionIndex.TREASURY_EXTERNAL_WITHDRAW_GUARD);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `New treasury type ${treasury_type} is not valid`);
     }
-    if (this.permission_address && this.data?.owner_receive != null) {
-      add_perm(BuiltinPermissionIndex.TREASURY_OWNER_RECEIVE);
+    if (passport) {
+        return tx.moveCall({
+            target: treasuryFn("new_with_passport"),
+            arguments: [
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxString(tx, description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-    if (this.permission_address && this.data?.um !== void 0) {
-      add_perm(BuiltinPermissionIndex.TREASURY_UM);
+    else {
+        return tx.moveCall({
+            target: treasuryFn("new"),
+            arguments: [
+                toTxObject(tx, permission),
+                toTxString(tx, description),
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-    if (this.permission_address || guards.length > 0) {
-      return await this.check_permission_and_call(
-        env,
-        this.permission_address,
-        perms,
-        guards
-      );
+}
+export function description_set(tx, treasury, treasury_type, permission, description, passport) {
+    validObjects([treasury, permission, passport]);
+    if (typeof description === "string" && !isValidDescription(description)) {
+        W_ERROR(WErrors.IsValidDescription, `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    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.parameter_type) {
-        object = newTreasury(
-          tx,
-          this.parameter_type,
-          permission,
-          this.data?.description ?? "",
-          passport
-        );
-      }
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Description set treasury type ${treasury_type} is not valid`);
     }
-    if (!object || !permission) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        "CallTreasury_Data.data.object:" + this.object_address
-      );
+    if (passport) {
+        tx.moveCall({
+            target: treasuryFn("description_set_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxString(tx, description),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-    if (this.data.description != null && !this.object_address) {
-      description_set(
-        tx,
-        object,
-        this.parameter_type,
-        permission,
-        this.data.description,
-        passport
-      );
+    else {
+        tx.moveCall({
+            target: treasuryFn("description_set"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxString(tx, description),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export async function deposit(env, tx, treasury, treasury_type, permission, coin, payment_info, passport) {
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Deposit treasury type ${treasury_type} is not valid`);
     }
-    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
+    const c = await getCoinParam(env, tx, coin, treasury_type);
+    const p = await paymentInfo(env, tx, payment_info);
+    if (passport) {
+        return tx.moveCall({
+            target: treasuryFn("deposit_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                c,
+                p,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
         });
-        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.parameter_type) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            `token_type ${this.data.receive.token_type} is not equal to parameter_type ${this.parameter_type}`
-          );
+    }
+    else {
+        return tx.moveCall({
+            target: treasuryFn("deposit"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                c,
+                p,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export async function withdraw(env, tx, treasury, treasury_type, permission, amount, recipient, payment_info, passport) {
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Withdraw treasury type ${treasury_type} is not valid`);
+    }
+    if (!isValidU64(amount)) {
+        W_ERROR(WErrors.IsValidU64, `Amount ${amount} is not valid`);
+    }
+    const r = await GetAccountOrMark_Address(recipient);
+    if (!r) {
+        W_ERROR(WErrors.InvalidParam, `Recipient ${recipient} is not valid`);
+    }
+    const p = await paymentInfo(env, tx, payment_info);
+    if (passport) {
+        return tx.moveCall({
+            target: treasuryFn("withdraw_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.pure.u64(amount),
+                tx.pure.address(r),
+                p,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: treasuryFn("withdraw"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                tx.pure.u64(amount),
+                tx.pure.address(r),
+                p,
+                tx.object.mutRegistrar(),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export async function external_deposit_guard_add(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
+    if (guards.length === 0) {
+        return;
+    }
+    if (guards.length > counts) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard add guards count ${guards.length} exceeds maximum ${counts}`);
+    }
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard add treasury type ${treasury_type} is not valid`);
+    }
+    const g = await Promise.all(guards.map(async (item) => {
+        const guard = await LocalMark.Instance().get_address(item.guard);
+        if (!guard) {
+            W_ERROR(WErrors.InvalidParam, `External deposit guard add guard ${item.guard} is not valid`);
         }
-        for (const item of this.data.receive.received) {
-          const [received_object, payment_object] = await Promise.all(
-            [
-              LocalMark.Instance().get_address(item.id),
-              LocalMark.Instance().get_address(item.payment)
-            ]
-          );
-          if (received_object && payment_object) {
-            receive(
-              tx,
-              object,
-              this.parameter_type,
-              permission,
-              received_object,
-              payment_object,
-              passport
-            );
-          } else {
-            W_ERROR(
-              WErrors.IsValidArgType,
-              `Receive object ${item.id} or payment object ${item.payment} not found`
-            );
-          }
+        if (item.identifier && !isValidU8(item.identifier)) {
+            W_ERROR(WErrors.IsValidU8, `External deposit guard add identifier ${item.identifier} is not optional u8`);
         }
-      }
+        return {
+            guard: item.guard,
+            identifier: item.identifier,
+            guard_addr: guard,
+        };
+    }));
+    // Check if any guard_addr is empty
+    const invalidGuards = g.filter((item) => !item.guard_addr);
+    if (invalidGuards.length > 0) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard add has invalid guards with empty guard_addr: ${JSON.stringify(invalidGuards)}`);
     }
-    if (this.data.deposit != null) {
-      if (this.data.deposit.by_external_deposit_guard) {
-        if (!passport) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            "Passport is required for external deposit"
-          );
+    // Convert to AmountFromDepositGuard if all guard_addr are valid
+    g.filter((item) => item.guard_addr !== undefined)
+        .map((item) => ({
+        guard: item.guard_addr,
+        identifier: item.identifier !== undefined ? item.identifier : null,
+    }))
+        .forEach((item) => {
+        if (passport) {
+            tx.moveCall({
+                target: treasuryFn("external_deposit_guard_add_with_passport"),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    toTxObject(tx, item.guard),
+                    tx.pure.option("u8", item.identifier),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
         }
-        await this.new_with_mark(
-          env,
-          tx,
-          ObjectType.Payment,
-          await external_deposit(
-            env,
-            tx,
-            object,
-            this.parameter_type,
-            passport,
-            this.data.deposit.by_external_deposit_guard,
-            this.data.deposit.coin,
-            this.data.deposit.payment_info
-          ),
-          this.data.deposit.namedNewPayment
-        );
-      } else {
-        await this.new_with_mark(
-          env,
-          tx,
-          ObjectType.Payment,
-          await deposit(
-            env,
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.deposit.coin,
-            this.data.deposit.payment_info,
-            passport
-          ),
-          this.data.deposit.namedNewPayment
-        );
-      }
-    }
-    if (this.data.withdraw != null && this.data.withdraw.amount) {
-      if ("fixed" in this.data.withdraw.amount) {
-        await this.new_with_mark(
-          env,
-          tx,
-          ObjectType.Payment,
-          await withdraw(
-            env,
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.withdraw.amount.fixed,
-            this.data.withdraw.recipient,
-            this.data.withdraw.payment_info,
-            passport
-          ),
-          this.data.withdraw.namedNewPayment
-        );
-      } else if ("by_external_withdraw_guard" in this.data.withdraw.amount) {
-        if (!passport) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            "Passport is required for external withdraw"
-          );
+        else {
+            tx.moveCall({
+                target: treasuryFn("external_deposit_guard_add"),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, item.guard),
+                    tx.pure.option("u8", item.identifier),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
         }
-        await this.new_with_mark(
-          env,
-          tx,
-          ObjectType.Payment,
-          await external_withdraw(
-            env,
-            tx,
-            object,
-            this.parameter_type,
-            passport,
-            this.data.withdraw.amount.by_external_withdraw_guard,
-            this.data.withdraw.recipient,
-            this.data.withdraw.payment_info
-          ),
-          this.data.withdraw.namedNewPayment
-        );
-      }
+    });
+}
+export async function external_deposit_guard_remove(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
+    guards = await LocalMark.Instance().get_many_address_availables(guards);
+    if (guards.length === 0) {
+        return;
     }
-    if (this.data.external_deposit_guard != null) {
-      switch (this.data.external_deposit_guard.op) {
-        case "add":
-        case "set": {
-          if (this.data.external_deposit_guard.op === "set") {
-            external_deposit_guard_clear(
-              tx,
-              object,
-              this.parameter_type,
-              permission,
-              passport
-            );
-          }
-          await external_deposit_guard_add(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.external_deposit_guard.guards,
-            MAX_EXTERNAL_DEPOSIT_GUARD_COUNT - (content?.external_deposit_guard?.length ?? 0),
-            passport
-          );
-          break;
-        }
-        case "remove": {
-          await external_deposit_guard_remove(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.external_deposit_guard.guards,
-            content?.external_deposit_guard?.length ?? 0,
-            passport
-          );
-          break;
+    if (guards.length > counts) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard remove guards count ${guards.length} exceeds maximum ${counts}`);
+    }
+    validObjects([treasury, permission, passport, ...guards]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard remove treasury type ${treasury_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: treasuryFn("external_deposit_guard_remove_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: treasuryFn("external_deposit_guard_remove"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export function external_deposit_guard_clear(tx, treasury, treasury_type, permission, passport) {
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard clear treasury type ${treasury_type} is not valid`);
+    }
+    if (passport) {
+        tx.moveCall({
+            target: treasuryFn("external_deposit_guard_clear_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: treasuryFn("external_deposit_guard_clear"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export async function external_withdraw_guard_add(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
+    if (guards.length === 0) {
+        return;
+    }
+    if (guards.length > counts) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard add guards count ${guards.length} exceeds maximum ${counts}`);
+    }
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard add treasury type ${treasury_type} is not valid`);
+    }
+    const g = await Promise.all(guards.map(async (item) => {
+        const guard = await LocalMark.Instance().get_address(item.guard);
+        if (!guard) {
+            W_ERROR(WErrors.InvalidParam, `External withdraw guard add guard ${item.guard} is not valid`);
         }
-        case "clear": {
-          external_deposit_guard_clear(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            passport
-          );
-          break;
+        if (!isValidU8(item.identifier)) {
+            W_ERROR(WErrors.IsValidU8, `External withdraw guard add identifier ${item.identifier} is not optional u8`);
         }
-      }
+        return {
+            guard: item.guard,
+            identifier: item.identifier,
+            guard_addr: guard,
+        };
+    }));
+    // Check if any guard_addr is empty
+    const invalidGuards = g.filter((item) => !item.guard_addr);
+    if (invalidGuards.length > 0) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard add has invalid guards with empty guard_addr: ${JSON.stringify(invalidGuards)}`);
     }
-    if (this.data.external_withdraw_guard != null) {
-      switch (this.data.external_withdraw_guard.op) {
-        case "add":
-        case "set": {
-          if (this.data.external_withdraw_guard.op === "set") {
-            external_withdraw_guard_clear(
-              tx,
-              object,
-              this.parameter_type,
-              permission,
-              passport
-            );
-          }
-          await external_withdraw_guard_add(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.external_withdraw_guard.guards,
-            MAX_EXTERNAL_WITHDRAW_GUARD_COUNT - (content?.external_withdraw_guard?.length ?? 0),
-            passport
-          );
-          break;
-        }
-        case "remove": {
-          await external_withdraw_guard_remove(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            this.data.external_withdraw_guard.guards,
-            content?.external_withdraw_guard?.length ?? 0,
-            passport
-          );
-          break;
+    // Convert to AmountFromWithdrawGuard if all guard_addr are valid
+    g.filter((item) => item.guard_addr !== undefined)
+        .map((item) => ({
+        guard: item.guard_addr,
+        identifier: item.identifier,
+    }))
+        .forEach((item) => {
+        if (passport) {
+            tx.moveCall({
+                target: treasuryFn("external_withdraw_guard_add_with_passport"),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, passport),
+                    toTxObject(tx, item.guard),
+                    tx.pure.u8(item.identifier),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
         }
-        case "clear": {
-          external_withdraw_guard_clear(
-            tx,
-            object,
-            this.parameter_type,
-            permission,
-            passport
-          );
-          break;
+        else {
+            /*console.log(
+                `External withdraw guard add guard ${item.guard} identifier ${item.identifier}`,
+            );*/
+            tx.moveCall({
+                target: treasuryFn("external_withdraw_guard_add"),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, item.guard),
+                    tx.pure.u8(item.identifier),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
         }
-      }
+    });
+}
+export async function external_withdraw_guard_remove(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
+    guards = await LocalMark.Instance().get_many_address_availables(guards);
+    if (guards.length === 0) {
+        return;
+    }
+    if (guards.length > counts) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard remove guards count ${guards.length} exceeds maximum ${counts}`);
+    }
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard remove treasury type ${treasury_type} is not valid`);
     }
-    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
+    if (passport) {
+        tx.moveCall({
+            target: treasuryFn("external_withdraw_guard_remove_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
         });
-      }
-      await owner_receive(
-        tx,
-        object,
-        permission,
-        this.data.owner_receive,
-        this.parameter_type,
-        (name) => `${PackageAddress}::treasury::${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,
-            "CallTreasury_Data.data.um:" + this.data.um
-          );
-        }
-      }
-      um_set(
-        tx,
-        object,
-        this.parameter_type,
-        permission,
-        um_address,
-        passport
-      );
+    else {
+        tx.moveCall({
+            target: treasuryFn("external_withdraw_guard_remove"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                tx.pure.vector("address", guards),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+}
+export function external_withdraw_guard_clear(tx, treasury, treasury_type, permission, passport) {
+    validObjects([treasury, permission, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard clear treasury type ${treasury_type} is not valid`);
     }
-    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 (passport) {
+        tx.moveCall({
+            target: treasuryFn("external_withdraw_guard_clear_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-    if (!this.object_address) {
-      await this.new_with_mark(
-        env,
-        tx,
-        ObjectType.Treasury,
-        create(tx, object, this.parameter_type),
-        GetObject(this.data?.object)
-      );
+    else {
+        tx.moveCall({
+            target: treasuryFn("external_withdraw_guard_clear"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                tx.object.mutRegistrar(),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-  }
 }
-const MAX_EXTERNAL_DEPOSIT_GUARD_COUNT = 100;
-const MAX_EXTERNAL_WITHDRAW_GUARD_COUNT = 200;
-function newTreasury(tx, treasury_type, permission, description, passport) {
-  validObjects([permission, passport]);
-  if (typeof description === "string" && !isValidDescription(description)) {
-    W_ERROR(
-      WErrors.IsValidDescription,
-      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `New treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    return tx.moveCall({
-      target: treasuryFn("new_with_passport"),
-      arguments: [
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxString(tx, description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
+export function create(tx, treasury, treasury_type) {
+    validObjects([treasury]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Create treasury type ${treasury_type} is not valid`);
+    }
     return tx.moveCall({
-      target: treasuryFn("new"),
-      arguments: [
-        toTxObject(tx, permission),
-        toTxString(tx, description),
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
-}
-function description_set(tx, treasury, treasury_type, permission, description, passport) {
-  validObjects([treasury, permission, passport]);
-  if (typeof description === "string" && !isValidDescription(description)) {
-    W_ERROR(
-      WErrors.IsValidDescription,
-      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Description set treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("description_set_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxString(tx, description)
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("description_set"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxString(tx, description)
-      ],
-      typeArguments: [treasury_type]
+        target: treasuryFn("create"),
+        arguments: [toTxObject(tx, treasury)],
+        typeArguments: [treasury_type],
     });
-  }
 }
-async function deposit(env, tx, treasury, treasury_type, permission, coin, payment_info, passport) {
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Deposit treasury type ${treasury_type} is not valid`
-    );
-  }
-  const c = await getCoinParam(env, tx, coin, treasury_type);
-  const p = await paymentInfo(env, tx, payment_info);
-  if (passport) {
-    return tx.moveCall({
-      target: treasuryFn("deposit_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        c,
-        p,
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
+export async function external_deposit(env, tx, treasury, treasury_type, passport, external_deposit_guard, coin, payment_info) {
+    validObjects([treasury, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External deposit treasury type ${treasury_type} is not valid`);
+    }
+    const [c, p, guard] = await Promise.all([
+        getCoinParam(env, tx, coin, treasury_type),
+        paymentInfo(env, tx, payment_info),
+        LocalMark.Instance().get_address(external_deposit_guard),
+    ]);
+    if (!guard) {
+        W_ERROR(WErrors.InvalidParam, `External deposit guard ${external_deposit_guard} is not valid`);
+    }
     return tx.moveCall({
-      target: treasuryFn("deposit"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        c,
-        p,
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
+        target: treasuryFn("external_deposit"),
+        arguments: [
+            toTxObject(tx, treasury),
+            toTxObject(tx, passport),
+            toTxObject(tx, guard),
+            c,
+            p,
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: [treasury_type],
     });
-  }
 }
-async function withdraw(env, tx, treasury, treasury_type, permission, amount, recipient, payment_info, passport) {
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Withdraw treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (!isValidU64(amount)) {
-    W_ERROR(WErrors.IsValidU64, `Amount ${amount} is not valid`);
-  }
-  const r = await GetAccountOrMark_Address(recipient);
-  if (!r) {
-    W_ERROR(WErrors.InvalidParam, `Recipient ${recipient} is not valid`);
-  }
-  const p = await paymentInfo(env, tx, payment_info);
-  if (passport) {
-    return tx.moveCall({
-      target: treasuryFn("withdraw_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.pure.u64(amount),
-        tx.pure.address(r),
-        p,
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
+export async function external_withdraw(env, tx, treasury, treasury_type, passport, external_withdraw_guard, recipient, payment_info) {
+    validObjects([treasury, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw treasury type ${treasury_type} is not valid`);
+    }
+    const [p, guard, recipient_addr] = await Promise.all([
+        paymentInfo(env, tx, payment_info),
+        LocalMark.Instance().get_address(external_withdraw_guard),
+        GetAccountOrMark_Address(recipient),
+    ]);
+    if (!guard) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw guard ${external_withdraw_guard} is not valid`);
+    }
+    if (!recipient_addr) {
+        W_ERROR(WErrors.InvalidParam, `External withdraw recipient ${recipient} is not valid`);
+    }
     return tx.moveCall({
-      target: treasuryFn("withdraw"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        tx.pure.u64(amount),
-        tx.pure.address(r),
-        p,
-        tx.object.mutRegistrar(),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
-}
-async function external_deposit_guard_add(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
-  if (guards.length === 0) {
-    return;
-  }
-  if (guards.length > counts) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard add guards count ${guards.length} exceeds maximum ${counts}`
-    );
-  }
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard add treasury type ${treasury_type} is not valid`
-    );
-  }
-  const g = await Promise.all(
-    guards.map(async (item) => {
-      const guard = await LocalMark.Instance().get_address(item.guard);
-      if (!guard) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `External deposit guard add guard ${item.guard} is not valid`
-        );
-      }
-      if (item.identifier && !isValidU8(item.identifier)) {
-        W_ERROR(
-          WErrors.IsValidU8,
-          `External deposit guard add identifier ${item.identifier} is not optional u8`
-        );
-      }
-      return {
-        guard: item.guard,
-        identifier: item.identifier,
-        guard_addr: guard
-      };
-    })
-  );
-  const invalidGuards = g.filter((item) => !item.guard_addr);
-  if (invalidGuards.length > 0) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard add has invalid guards with empty guard_addr: ${JSON.stringify(invalidGuards)}`
-    );
-  }
-  g.filter((item) => item.guard_addr !== void 0).map((item) => ({
-    guard: item.guard_addr,
-    identifier: item.identifier !== void 0 ? item.identifier : null
-  })).forEach((item) => {
-    if (passport) {
-      tx.moveCall({
-        target: treasuryFn(
-          "external_deposit_guard_add_with_passport"
-        ),
+        target: treasuryFn("external_withdraw"),
         arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          toTxObject(tx, passport),
-          toTxObject(tx, item.guard),
-          tx.pure.option("u8", item.identifier),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
+            toTxObject(tx, treasury),
+            toTxObject(tx, passport),
+            toTxObject(tx, guard),
+            tx.pure.address(recipient_addr),
+            p,
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
         ],
-        typeArguments: [treasury_type]
-      });
-    } else {
-      tx.moveCall({
-        target: treasuryFn("external_deposit_guard_add"),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          toTxObject(tx, item.guard),
-          tx.pure.option("u8", item.identifier),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [treasury_type]
-      });
-    }
-  });
-}
-async function external_deposit_guard_remove(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
-  guards = await LocalMark.Instance().get_many_address_availables(guards);
-  if (guards.length === 0) {
-    return;
-  }
-  if (guards.length > counts) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard remove guards count ${guards.length} exceeds maximum ${counts}`
-    );
-  }
-  validObjects([treasury, permission, passport, ...guards]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard remove treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("external_deposit_guard_remove_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("external_deposit_guard_remove"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
+        typeArguments: [treasury_type],
     });
-  }
 }
-function external_deposit_guard_clear(tx, treasury, treasury_type, permission, passport) {
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard clear treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("external_deposit_guard_clear_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("external_deposit_guard_clear"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
-}
-async function external_withdraw_guard_add(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
-  if (guards.length === 0) {
-    return;
-  }
-  if (guards.length > counts) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard add guards count ${guards.length} exceeds maximum ${counts}`
-    );
-  }
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard add treasury type ${treasury_type} is not valid`
-    );
-  }
-  const g = await Promise.all(
-    guards.map(async (item) => {
-      const guard = await LocalMark.Instance().get_address(item.guard);
-      if (!guard) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `External withdraw guard add guard ${item.guard} is not valid`
-        );
-      }
-      if (!isValidU8(item.identifier)) {
-        W_ERROR(
-          WErrors.IsValidU8,
-          `External withdraw guard add identifier ${item.identifier} is not optional u8`
-        );
-      }
-      return {
-        guard: item.guard,
-        identifier: item.identifier,
-        guard_addr: guard
-      };
-    })
-  );
-  const invalidGuards = g.filter((item) => !item.guard_addr);
-  if (invalidGuards.length > 0) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard add has invalid guards with empty guard_addr: ${JSON.stringify(invalidGuards)}`
-    );
-  }
-  g.filter((item) => item.guard_addr !== void 0).map((item) => ({
-    guard: item.guard_addr,
-    identifier: item.identifier
-  })).forEach((item) => {
+export function receive(tx, treasury, treasury_type, permission, received, payment, passport) {
+    if (!payment) {
+        W_ERROR(WErrors.InvalidParam, `Treasury receive payment is required`);
+    }
+    validObjects([treasury, permission, received, payment, passport]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Treasury receive treasury type ${treasury_type} is not valid`);
+    }
     if (passport) {
-      tx.moveCall({
-        target: treasuryFn(
-          "external_withdraw_guard_add_with_passport"
-        ),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          toTxObject(tx, passport),
-          toTxObject(tx, item.guard),
-          tx.pure.u8(item.identifier),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [treasury_type]
-      });
-    } else {
-      tx.moveCall({
-        target: treasuryFn("external_withdraw_guard_add"),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          toTxObject(tx, item.guard),
-          tx.pure.u8(item.identifier),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [treasury_type]
-      });
+        tx.moveCall({
+            target: treasuryFn("receive_with_passport"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, passport),
+                toTxObject(tx, received),
+                toTxObject(tx, payment),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
+    }
+    else {
+        tx.moveCall({
+            target: treasuryFn("receive"),
+            arguments: [
+                toTxObject(tx, treasury),
+                toTxObject(tx, permission),
+                toTxObject(tx, received),
+                toTxObject(tx, payment),
+                tx.object.clock(),
+            ],
+            typeArguments: [treasury_type],
+        });
     }
-  });
-}
-async function external_withdraw_guard_remove(tx, treasury, treasury_type, permission, guards, counts = MAX_EXTERNAL_DEPOSIT_GUARD_COUNT, passport) {
-  guards = await LocalMark.Instance().get_many_address_availables(guards);
-  if (guards.length === 0) {
-    return;
-  }
-  if (guards.length > counts) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard remove guards count ${guards.length} exceeds maximum ${counts}`
-    );
-  }
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard remove treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("external_withdraw_guard_remove_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("external_withdraw_guard_remove"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        tx.pure.vector("address", guards),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
-}
-function external_withdraw_guard_clear(tx, treasury, treasury_type, permission, passport) {
-  validObjects([treasury, permission, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard clear treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("external_withdraw_guard_clear_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("external_withdraw_guard_clear"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        tx.object.mutRegistrar()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
-}
-function create(tx, treasury, treasury_type) {
-  validObjects([treasury]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Create treasury type ${treasury_type} is not valid`
-    );
-  }
-  return tx.moveCall({
-    target: treasuryFn("create"),
-    arguments: [toTxObject(tx, treasury)],
-    typeArguments: [treasury_type]
-  });
-}
-async function external_deposit(env, tx, treasury, treasury_type, passport, external_deposit_guard, coin, payment_info) {
-  validObjects([treasury, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit treasury type ${treasury_type} is not valid`
-    );
-  }
-  const [c, p, guard] = await Promise.all([
-    getCoinParam(env, tx, coin, treasury_type),
-    paymentInfo(env, tx, payment_info),
-    LocalMark.Instance().get_address(external_deposit_guard)
-  ]);
-  if (!guard) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External deposit guard ${external_deposit_guard} is not valid`
-    );
-  }
-  return tx.moveCall({
-    target: treasuryFn("external_deposit"),
-    arguments: [
-      toTxObject(tx, treasury),
-      toTxObject(tx, passport),
-      toTxObject(tx, guard),
-      c,
-      p,
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [treasury_type]
-  });
-}
-async function external_withdraw(env, tx, treasury, treasury_type, passport, external_withdraw_guard, recipient, payment_info) {
-  validObjects([treasury, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw treasury type ${treasury_type} is not valid`
-    );
-  }
-  const [p, guard, recipient_addr] = await Promise.all([
-    paymentInfo(env, tx, payment_info),
-    LocalMark.Instance().get_address(external_withdraw_guard),
-    GetAccountOrMark_Address(recipient)
-  ]);
-  if (!guard) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw guard ${external_withdraw_guard} is not valid`
-    );
-  }
-  if (!recipient_addr) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `External withdraw recipient ${recipient} is not valid`
-    );
-  }
-  return tx.moveCall({
-    target: treasuryFn("external_withdraw"),
-    arguments: [
-      toTxObject(tx, treasury),
-      toTxObject(tx, passport),
-      toTxObject(tx, guard),
-      tx.pure.address(recipient_addr),
-      p,
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [treasury_type]
-  });
-}
-function receive(tx, treasury, treasury_type, permission, received, payment, passport) {
-  if (!payment) {
-    W_ERROR(WErrors.InvalidParam, `Treasury receive payment is required`);
-  }
-  validObjects([treasury, permission, received, payment, passport]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Treasury receive treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (passport) {
-    tx.moveCall({
-      target: treasuryFn("receive_with_passport"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, passport),
-        toTxObject(tx, received),
-        toTxObject(tx, payment),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  } else {
-    tx.moveCall({
-      target: treasuryFn("receive"),
-      arguments: [
-        toTxObject(tx, treasury),
-        toTxObject(tx, permission),
-        toTxObject(tx, received),
-        toTxObject(tx, payment),
-        tx.object.clock()
-      ],
-      typeArguments: [treasury_type]
-    });
-  }
 }
-function um_set(tx, treasury, treasury_type, permission, um, passport) {
-  validObjects([treasury, permission]);
-  if (!IsValidArgType(treasury_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Treasury type ${treasury_type} is not valid`
-    );
-  }
-  if (um) {
-    if (passport) {
-      tx.moveCall({
-        target: treasuryFn(`um_set_with_passport`),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          passport,
-          toTxObject(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [treasury_type]
-      });
-    } else {
-      tx.moveCall({
-        target: treasuryFn(`um_set`),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          toTxObject(tx, um),
-          tx.object.mutRegistrar(),
-          tx.object.clock()
-        ],
-        typeArguments: [treasury_type]
-      });
+export function um_set(tx, treasury, treasury_type, permission, um, passport) {
+    validObjects([treasury, permission]);
+    if (!IsValidArgType(treasury_type)) {
+        W_ERROR(WErrors.InvalidParam, `Treasury type ${treasury_type} is not valid`);
     }
-  } else {
-    if (passport) {
-      tx.moveCall({
-        target: treasuryFn(`um_none_with_passport`),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          passport,
-          tx.object.mutRegistrar()
-        ],
-        typeArguments: [treasury_type]
-      });
-    } else {
-      tx.moveCall({
-        target: treasuryFn(`um_none`),
-        arguments: [
-          toTxObject(tx, treasury),
-          toTxObject(tx, permission),
-          tx.object.mutRegistrar()
-        ],
-        typeArguments: [treasury_type]
-      });
+    if (um) {
+        if (passport) {
+            tx.moveCall({
+                target: treasuryFn(`um_set_with_passport`),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    passport,
+                    toTxObject(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: treasuryFn(`um_set`),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    toTxObject(tx, um),
+                    tx.object.mutRegistrar(),
+                    tx.object.clock(),
+                ],
+                typeArguments: [treasury_type],
+            });
+        }
+    }
+    else {
+        if (passport) {
+            tx.moveCall({
+                target: treasuryFn(`um_none_with_passport`),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    passport,
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [treasury_type],
+            });
+        }
+        else {
+            tx.moveCall({
+                target: treasuryFn(`um_none`),
+                arguments: [
+                    toTxObject(tx, treasury),
+                    toTxObject(tx, permission),
+                    tx.object.mutRegistrar(),
+                ],
+                typeArguments: [treasury_type],
+            });
+        }
     }
-  }
 }
-export {
-  CallTreasury,
-  MAX_EXTERNAL_DEPOSIT_GUARD_COUNT,
-  MAX_EXTERNAL_WITHDRAW_GUARD_COUNT,
-  create,
-  deposit,
-  description_set,
-  external_deposit,
-  external_deposit_guard_add,
-  external_deposit_guard_clear,
-  external_deposit_guard_remove,
-  external_withdraw,
-  external_withdraw_guard_add,
-  external_withdraw_guard_clear,
-  external_withdraw_guard_remove,
-  newTreasury,
-  receive,
-  um_set,
-  withdraw
-};
+//# sourceMappingURL=treasury.js.map