wowok 1.8.2 → 2.1.9

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

@@ -0,0 +1,1186 @@
+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";
+import { W_ERROR, WErrors } from "../exception.js";
+import { ObjectType } from "../query/object.js";
+import { owner_receive, parseObjectType, validObjects } from "../util.js";
+import { CallBase, getCoinParam } from "./base.js";
+import { BuiltinPermissionIndex, newPermission } from "./permission.js";
+import { GetAccountOrMark_Address } from "../local/index.js";
+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);
+    }
+    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);
+    }
+    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 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`
+            );
+          }
+        }
+      }
+    }
+    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 !== void 0) {
+      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);
+  }
+  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
+        });
+        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}`
+          );
+        }
+        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
+        });
+      }
+      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
+      );
+    }
+    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)
+      );
+    }
+  }
+}
+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 {
+    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]
+    });
+  }
+}
+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 {
+    return tx.moveCall({
+      target: treasuryFn("deposit"),
+      arguments: [
+        toTxObject(tx, treasury),
+        toTxObject(tx, permission),
+        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 {
+    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"
+        ),
+        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]
+      });
+    } 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]
+    });
+  }
+}
+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) => {
+    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]
+      });
+    }
+  });
+}
+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]
+      });
+    }
+  } 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
+};