wowok 2.1.9 → 2.1.12

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

@@ -1,439 +1,349 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var allocation_exports = {};
-__export(allocation_exports, {
-  CallAllocation: () => CallAllocation,
-  MAX_ALLOCATOR_COUNT: () => MAX_ALLOCATOR_COUNT,
-  MAX_SHARING_COUNT: () => MAX_SHARING_COUNT,
-  alloc: () => alloc,
-  allocationFn: () => allocationFn,
-  allocators: () => allocators,
-  create: () => create,
-  newAllocation: () => newAllocation,
-  receive: () => receive,
-  sharing: () => sharing
-});
-module.exports = __toCommonJS(allocation_exports);
-var import_sui_types = require("../../utils/sui-types.js");
-var import_common = require("../common.js");
-var import_exception = require("../exception.js");
-var import_local = require("../local/index.js");
-var import_local2 = require("../local/local.js");
-var import_object = require("../query/object.js");
-var import_received = require("../query/received.js");
-var import_util = require("../util.js");
-var import_base = require("./base.js");
-var import_passport = require("./passport.js");
-var import_payment = require("./payment.js");
-class CallAllocation extends import_base.CallBase {
-  //object_data: ObjectPermission | undefined = undefined;
-  constructor(data) {
-    super();
-    __publicField(this, "data");
-    __publicField(this, "object_address");
-    __publicField(this, "type_parameter");
-    this.data = data;
-  }
-  async prepare(env) {
-    await super.prepare(env);
-    if (!this.object_address) {
-      this.object_address = await (0, import_common.GetObjectExisted)(this.data?.object);
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allocators = exports.sharing = exports.MAX_SHARING_COUNT = exports.MAX_ALLOCATOR_COUNT = exports.CallAllocation = void 0;
+exports.allocationFn = allocationFn;
+exports.alloc = alloc;
+exports.newAllocation = newAllocation;
+exports.create = create;
+exports.receive = receive;
+const sui_types_js_1 = require("../../utils/sui-types.js");
+const common_js_1 = require("../common.js");
+const exception_js_1 = require("../exception.js");
+const index_js_1 = require("../local/index.js");
+const local_js_1 = require("../local/local.js");
+const object_js_1 = require("../query/object.js");
+const received_js_1 = require("../query/received.js");
+const util_js_1 = require("../util.js");
+const base_js_1 = require("./base.js");
+const passport_js_1 = require("./passport.js");
+const payment_js_1 = require("./payment.js");
+class CallAllocation extends base_js_1.CallBase {
+    data;
+    object_address = undefined;
+    type_parameter = undefined;
+    //object_data: ObjectPermission | undefined = undefined;
+    constructor(data) {
+        super();
+        this.data = data;
     }
-    if (this.object_address) {
-      await this.update_content(
-        env,
-        import_object.ObjectType.Allocation,
-        this.object_address
-      );
-      if (!this.content) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          "CallAllocation_Data.data.object:" + this.object_address
-        );
-      }
-      this.type_parameter = (0, import_util.parseObjectType)(
-        this.content.type_raw,
-        "allocation::Allocation"
-      );
-      if (!this.type_parameter) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          "CallAllocation_Data.data.object.type_parameter is empty"
-        );
-      }
-    } else {
-      const n = (0, import_common.GetObject)(this.data.object);
-      if (!n || !(0, import_common.IsValidArgType)(n?.type_parameter)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          "CallAllocation_Data.data.object.type_parameter is empty"
-        );
-      }
-      this.type_parameter = n?.type_parameter;
-    }
-  }
-  async call(env) {
-    await this.prepare(env);
-    if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
-      const g = await import_local2.LocalMark.Instance().get_address(
-        this.data.alloc_by_guard
-      );
-      if (!g || !(0, import_sui_types.isValidWowAddress)(g)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidAddress,
-          `alloc_by_guard: ${this.data.alloc_by_guard}`
-        );
-      }
-      if (this.content && !this.content.allocators.find(
-        (item) => item.guard === g
-      )) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `alloc_by_guard: ${this.data.alloc_by_guard} not found in allocators ${this.content.allocators.map((item) => item.guard)}`
-        );
-      }
-      this.data.alloc_by_guard = g;
-      const param = await (0, import_passport.get_guardSubmissions)(env, [
-        this.data.alloc_by_guard
-      ]);
-      if (param.submission.length > 0) {
-        return {
-          type: "submission",
-          guard: param.guard,
-          submission: param.submission
-        };
-      }
-      return await this.check_passport(env, param);
+    async prepare(env) {
+        await super.prepare(env);
+        if (!this.object_address) {
+            this.object_address = await (0, common_js_1.GetObjectExisted)(this.data?.object);
+        }
+        if (this.object_address) {
+            await this.update_content(env, object_js_1.ObjectType.Allocation, this.object_address);
+            if (!this.content) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.object:" + this.object_address);
+            }
+            this.type_parameter = (0, util_js_1.parseObjectType)(this.content.type_raw, "allocation::Allocation");
+            if (!this.type_parameter) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallAllocation_Data.data.object.type_parameter is empty");
+            }
+        }
+        else {
+            const n = (0, common_js_1.GetObject)(this.data.object);
+            if (!n || !(0, common_js_1.IsValidArgType)(n?.type_parameter)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, "CallAllocation_Data.data.object.type_parameter is empty");
+            }
+            this.type_parameter = n?.type_parameter;
+        }
     }
-    return await this.exec(env);
-  }
-  async operate(env, tx, passport) {
-    if (this.object_address) {
-      if ("received_coins" in this.data && this.data.received_coins != null) {
-        if (this.data.received_coins === "recently") {
-          const received = await (0, import_received.query_received)({
-            object: this.object_address,
-            network: env.network,
-            no_cache: env.no_cache
-          });
-          if (Array.isArray(received)) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]"
-            );
-          } else {
-            this.data.received_coins = received;
-          }
+    async call(env) {
+        await this.prepare(env);
+        if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
+            const g = await local_js_1.LocalMark.Instance().get_address(this.data.alloc_by_guard);
+            if (!g || !(0, sui_types_js_1.isValidWowAddress)(g)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `alloc_by_guard: ${this.data.alloc_by_guard}`);
+            }
+            if (this.content &&
+                !this.content.allocators.find((item) => item.guard === g)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `alloc_by_guard: ${this.data.alloc_by_guard} not found in allocators ${this.content.allocators.map((item) => item.guard)}`);
+            }
+            this.data.alloc_by_guard = g; // 更新该值，后面不需要再去查询
+            const param = await (0, passport_js_1.get_guardSubmissions)(env, [
+                this.data.alloc_by_guard,
+            ]);
+            if (param.submission.length > 0) {
+                return {
+                    type: "submission",
+                    guard: param.guard,
+                    submission: param.submission,
+                };
+            }
+            return await this.check_passport(env, param);
         }
-        if (typeof this.data.received_coins === "object" && "received" in this.data.received_coins && this.data.received_coins.received?.length > 0) {
-          if (this.data.received_coins?.token_type !== this.type_parameter) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.InvalidParam,
-              "CallAllocation_Data.data.received_coins.token_type:" + this.data.received_coins?.token_type
-            );
-          }
-          for (const v of this.data.received_coins.received) {
-            if (!(0, import_sui_types.isValidWowAddress)(v.id) || !(0, import_sui_types.isValidWowAddress)(v.payment)) {
-              (0, import_exception.W_ERROR)(
-                import_exception.WErrors.InvalidParam,
-                "CallAllocation_Data.data.received_coins:" + v.id
-              );
+        return await this.exec(env);
+    }
+    async operate(env, tx, passport) {
+        if (this.object_address) {
+            if ("received_coins" in this.data &&
+                this.data.received_coins != null) {
+                if (this.data.received_coins === "recently") {
+                    const received = await (0, received_js_1.query_received)({
+                        object: this.object_address,
+                        network: env.network,
+                        no_cache: env.no_cache,
+                    });
+                    // 检查received的类型，如果是ReceivedNormal[]，需要转换为ReceivedBalance
+                    if (Array.isArray(received)) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.received_coins: received is ReceivedNormal[]");
+                    }
+                    else {
+                        // 如果是ReceivedBalance类型，直接赋值
+                        this.data.received_coins = received;
+                    }
+                }
+                if (typeof this.data.received_coins === "object" &&
+                    "received" in this.data.received_coins &&
+                    this.data.received_coins.received?.length > 0) {
+                    if (this.data.received_coins?.token_type !==
+                        this.type_parameter) {
+                        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.received_coins.token_type:" +
+                            this.data.received_coins?.token_type);
+                    }
+                    for (const v of this.data.received_coins.received) {
+                        // 这里假设v.id是CoinWrapper类型的对象
+                        if (!(0, sui_types_js_1.isValidWowAddress)(v.id) ||
+                            !(0, sui_types_js_1.isValidWowAddress)(v.payment)) {
+                            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.received_coins:" +
+                                v.id);
+                        }
+                        receive(tx, (0, common_js_1.toTxObject)(tx, this.object_address), this.type_parameter, (0, common_js_1.toTxObject)(tx, v.id), (0, common_js_1.toTxObject)(tx, v.payment));
+                    }
+                }
+            }
+            if ("alloc_by_guard" in this.data &&
+                this.data.alloc_by_guard != null) {
+                if (!passport) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, "CallAllocation_Data.data.alloc_by_guard:" +
+                        this.data.alloc_by_guard);
+                }
+                alloc(tx, (0, common_js_1.toTxObject)(tx, this.object_address), this.type_parameter, this.data.alloc_by_guard, passport);
             }
-            receive(
-              tx,
-              (0, import_common.toTxObject)(tx, this.object_address),
-              this.type_parameter,
-              (0, import_common.toTxObject)(tx, v.id),
-              (0, import_common.toTxObject)(tx, v.payment)
-            );
-          }
         }
-      }
-      if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
-        if (!passport) {
-          (0, import_exception.W_ERROR)(
-            import_exception.WErrors.InvalidParam,
-            "CallAllocation_Data.data.alloc_by_guard:" + this.data.alloc_by_guard
-          );
+        else {
+            const n = (0, common_js_1.GetObject)(this.data.object);
+            if (!(0, common_js_1.IsValidArgType)(n?.type_parameter)) {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidArgType, `CallAllocation_Data.data.object.type_parameter ${n?.type_parameter}`);
+            }
+            this.type_parameter = n?.type_parameter;
+            let coin;
+            // 检查是否是包含 coin 属性的类型
+            if ("coin" in this.data && this.data.coin) {
+                coin = await (0, base_js_1.getCoinParam)(env, tx, this.data.coin, this.type_parameter);
+            }
+            if (coin &&
+                "allocators" in this.data &&
+                this.data.allocators &&
+                this.type_parameter) {
+                const allocation = newAllocation(tx, this.type_parameter, coin, await (0, exports.allocators)(tx, this.data.allocators));
+                await this.new_with_mark(env, tx, object_js_1.ObjectType.Allocation, create(tx, allocation, this.type_parameter, await (0, payment_js_1.paymentInfo)(env, tx, this.data.payment_info)), n);
+            }
+            else {
+                (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `CallAllocation_Data.data ${JSON.stringify(this.data)}`);
+            }
         }
-        alloc(
-          tx,
-          (0, import_common.toTxObject)(tx, this.object_address),
-          this.type_parameter,
-          this.data.alloc_by_guard,
-          passport
-        );
-      }
-    } else {
-      const n = (0, import_common.GetObject)(this.data.object);
-      if (!(0, import_common.IsValidArgType)(n?.type_parameter)) {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.IsValidArgType,
-          `CallAllocation_Data.data.object.type_parameter ${n?.type_parameter}`
-        );
-      }
-      this.type_parameter = n?.type_parameter;
-      let coin;
-      if ("coin" in this.data && this.data.coin) {
-        coin = await (0, import_base.getCoinParam)(
-          env,
-          tx,
-          this.data.coin,
-          this.type_parameter
-        );
-      }
-      if (coin && "allocators" in this.data && this.data.allocators && this.type_parameter) {
-        const allocation = newAllocation(
-          tx,
-          this.type_parameter,
-          coin,
-          await allocators(tx, this.data.allocators)
-        );
-        await this.new_with_mark(
-          env,
-          tx,
-          import_object.ObjectType.Allocation,
-          create(
-            tx,
-            allocation,
-            this.type_parameter,
-            await (0, import_payment.paymentInfo)(env, tx, this.data.payment_info)
-          ),
-          n
-        );
-      } else {
-        (0, import_exception.W_ERROR)(
-          import_exception.WErrors.InvalidParam,
-          `CallAllocation_Data.data ${JSON.stringify(this.data)}`
-        );
-      }
     }
-  }
 }
+exports.CallAllocation = CallAllocation;
+// ================================================
 function allocationFn(name) {
-  return `${import_common.PackageAddress}::allocation::${name}`;
+    return `${common_js_1.PackageAddress}::allocation::${name}`;
 }
-const MAX_ALLOCATOR_COUNT = 100;
-const MAX_SHARING_COUNT = 100;
-const sharing = async (tx, sharing2, preResolvedAddress) => {
-  if ("GuardIdentifier" in sharing2.who) {
-    if (!(0, import_common.isValidU8)(sharing2.who.GuardIdentifier)) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.IsValidU8,
-        `sharing GuardIdentifier: ${sharing2.who.GuardIdentifier}`
-      );
+exports.MAX_ALLOCATOR_COUNT = 100;
+exports.MAX_SHARING_COUNT = 100;
+// ================================================
+const sharing = async (tx, sharing, preResolvedAddress) => {
+    if ("GuardIdentifier" in sharing.who) {
+        if (!(0, common_js_1.isValidU8)(sharing.who.GuardIdentifier)) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidU8, `sharing GuardIdentifier: ${sharing.who.GuardIdentifier}`);
+        }
+        return tx.moveCall({
+            target: allocationFn("sharing_for_guard_identifier"),
+            arguments: [
+                tx.pure.u8(sharing.who.GuardIdentifier),
+                tx.pure.u64(sharing.sharing),
+                tx.pure.u8(Number(sharing.mode)),
+            ],
+        });
     }
-    return tx.moveCall({
-      target: allocationFn("sharing_for_guard_identifier"),
-      arguments: [
-        tx.pure.u8(sharing2.who.GuardIdentifier),
-        tx.pure.u64(sharing2.sharing),
-        tx.pure.u8(Number(sharing2.mode))
-      ]
-    });
-  } else if ("Entity" in sharing2.who) {
-    const addr = preResolvedAddress || await (0, import_local.GetAccountOrMark_Address)(sharing2.who.Entity);
-    if (!addr) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.IsValidAddress,
-        `sharing Entity: ${sharing2.who.Entity}`
-      );
+    else if ("Entity" in sharing.who) {
+        const addr = preResolvedAddress ||
+            (await (0, index_js_1.GetAccountOrMark_Address)(sharing.who.Entity));
+        if (!addr) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `sharing Entity: ${sharing.who.Entity}`);
+        }
+        return tx.moveCall({
+            target: allocationFn("sharing_for_address"),
+            arguments: [
+                tx.pure.address(addr),
+                tx.pure.u64(sharing.sharing),
+                tx.pure.u8(Number(sharing.mode)),
+            ],
+        });
+    }
+    else {
+        return tx.moveCall({
+            target: allocationFn("sharing_for_signer"),
+            arguments: [
+                tx.pure.u64(sharing.sharing),
+                tx.pure.u8(Number(sharing.mode)),
+            ],
+        });
     }
-    return tx.moveCall({
-      target: allocationFn("sharing_for_address"),
-      arguments: [
-        tx.pure.address(addr),
-        tx.pure.u64(sharing2.sharing),
-        tx.pure.u8(Number(sharing2.mode))
-      ]
-    });
-  } else {
-    return tx.moveCall({
-      target: allocationFn("sharing_for_signer"),
-      arguments: [
-        tx.pure.u64(sharing2.sharing),
-        tx.pure.u8(Number(sharing2.mode))
-      ]
-    });
-  }
 };
+exports.sharing = sharing;
 const allocators = async (tx, param) => {
-  if (!(0, import_common.isValidDescription)(param.description)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Description exceeds maximum length ${import_common.MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (param.allocators.length > MAX_ALLOCATOR_COUNT) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `Allocator count exceeds maximum limit ${MAX_ALLOCATOR_COUNT}`
-    );
-  }
-  if (param.allocators.length === 0) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `Allocator array cannot be empty`);
-  }
-  if (!(0, import_common.isValidU64)(param.threshold)) {
-    (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `threshold: ${param.threshold}`);
-  }
-  const allocators_obj = tx.moveCall({
-    target: allocationFn("allocators"),
-    arguments: [
-      tx.pure.string(param.description),
-      tx.pure.u64(param.threshold)
-    ]
-  });
-  for (let i = 0; i < param.allocators.length; i++) {
-    const allocator = param.allocators[i];
-    if (allocator.sharing.length === 0) {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.InvalidParam, `sharing array cannot be empty`);
+    if (!(0, common_js_1.isValidDescription)(param.description)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Description exceeds maximum length ${common_js_1.MAX_DESCRIPTION_LENGTH}`);
     }
-    if (allocator.sharing.length > MAX_SHARING_COUNT) {
-      (0, import_exception.W_ERROR)(
-        import_exception.WErrors.InvalidParam,
-        `sharing count exceeds maximum limit ${MAX_SHARING_COUNT}`
-      );
+    if (param.allocators.length > exports.MAX_ALLOCATOR_COUNT) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Allocator count exceeds maximum limit ${exports.MAX_ALLOCATOR_COUNT}`);
     }
-    const entityItems = allocator.sharing.map((s, index) => {
-      if ("Entity" in s.who) {
-        return {
-          index,
-          name_or_address: s.who.Entity.name_or_address
-        };
-      } else {
-        return null;
-      }
-    }).filter(
-      (item) => item !== null
-    );
-    const [g, entityAddrs] = await Promise.all([
-      import_local2.LocalMark.Instance().get_address(allocator.guard),
-      // 只转换 Entity 类型
-      (0, import_local.GetManyAccountOrMark_Address)({
-        entities: entityItems,
-        check_all_founded: true
-      })
-    ]);
-    const addrs = new Array(allocator.sharing.length);
-    entityItems.forEach((item, entityIndex) => {
-      addrs[item.index] = entityAddrs[entityIndex];
-    });
-    if (!g) {
-      (0, import_exception.W_ERROR)(import_exception.WErrors.IsValidAddress, `guard: ${allocator.guard}`);
+    if (param.allocators.length === 0) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `Allocator array cannot be empty`);
     }
-    const sharingElements = await Promise.all(
-      allocator.sharing.map(async (s, index) => {
-        if ("Entity" in s.who) {
-          const addr = addrs[index];
-          if (!addr) {
-            (0, import_exception.W_ERROR)(
-              import_exception.WErrors.IsValidAddress,
-              `entity: ${typeof s.who.Entity === "string" ? s.who.Entity : s.who.Entity.name_or_address}`
-            );
-          }
-          return sharing(tx, s, addr);
-        } else {
-          return sharing(tx, s);
-        }
-      })
-    );
-    const makeMoveVecResult = tx.makeMoveVec({
-      elements: sharingElements,
-      type: `${import_common.PackageAddress}::allocation::Sharing`
-      //@ must specify type
-    });
-    tx.moveCall({
-      target: allocationFn("allocator_add"),
-      arguments: [
-        allocators_obj,
-        (0, import_common.toTxObject)(tx, g),
-        makeMoveVecResult,
-        tx.pure.option("u64", allocator?.max)
-      ]
+    if (!(0, common_js_1.isValidU64)(param.threshold)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `threshold: ${param.threshold}`);
+    }
+    //console.log(`threshold: ${param.threshold}`);
+    const allocators_obj = tx.moveCall({
+        target: allocationFn("allocators"),
+        arguments: [
+            tx.pure.string(param.description),
+            tx.pure.u64(param.threshold),
+        ],
     });
-  }
-  return allocators_obj;
+    for (let i = 0; i < param.allocators.length; i++) {
+        const allocator = param.allocators[i];
+        if (allocator.sharing.length === 0) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `sharing array cannot be empty`);
+        }
+        if (allocator.sharing.length > exports.MAX_SHARING_COUNT) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `sharing count exceeds maximum limit ${exports.MAX_SHARING_COUNT}`);
+        }
+        // 准备需要转换的 Entity 类型数据，保持原数组顺序
+        const entityItems = allocator.sharing
+            .map((s, index) => {
+            if ("Entity" in s.who) {
+                return {
+                    index,
+                    name_or_address: s.who.Entity.name_or_address,
+                };
+            }
+            else {
+                return null;
+            }
+        })
+            .filter((item) => item !== null);
+        // 并行处理地址获取，提高执行效率
+        const [g, entityAddrs] = await Promise.all([
+            local_js_1.LocalMark.Instance().get_address(allocator.guard),
+            // 只转换 Entity 类型
+            (0, index_js_1.GetManyAccountOrMark_Address)({
+                entities: entityItems,
+                check_all_founded: true,
+            }),
+        ]);
+        // 构建地址映射，保持原数组顺序
+        const addrs = new Array(allocator.sharing.length);
+        entityItems.forEach((item, entityIndex) => {
+            addrs[item.index] = entityAddrs[entityIndex];
+        });
+        if (!g) {
+            (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `guard: ${allocator.guard}`);
+        }
+        // 构建 sharing 数组，对于 entity 类型使用转换后的地址
+        const sharingElements = await Promise.all(allocator.sharing.map(async (s, index) => {
+            // 如果是 Entity 类型，使用转换后的地址
+            if ("Entity" in s.who) {
+                const addr = addrs[index];
+                if (!addr) {
+                    (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.IsValidAddress, `entity: ${typeof s.who.Entity === "string" ? s.who.Entity : s.who.Entity.name_or_address}`);
+                }
+                // 直接传递预解析的地址，避免重复查询
+                return (0, exports.sharing)(tx, s, addr);
+            }
+            else {
+                // 其他类型保持不变
+                return (0, exports.sharing)(tx, s);
+            }
+        }));
+        // 使用 tx.makeMoveVec 创建向量，它会自动处理元素类型转换
+        const makeMoveVecResult = tx.makeMoveVec({
+            elements: sharingElements,
+            type: `${common_js_1.PackageAddress}::allocation::Sharing`, //@ must specify type
+        });
+        tx.moveCall({
+            target: allocationFn("allocator_add"),
+            arguments: [
+                allocators_obj,
+                (0, common_js_1.toTxObject)(tx, g),
+                makeMoveVecResult,
+                tx.pure.option("u64", allocator?.max),
+            ],
+        });
+    }
+    return allocators_obj;
 };
+exports.allocators = allocators;
 function alloc(tx, allocation, allocation_type, guard, passport) {
-  (0, import_util.validObjects)([allocation, guard, passport]);
-  if (!(0, import_common.IsValidArgType)(allocation_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  tx.moveCall({
-    target: allocationFn("alloc"),
-    arguments: [
-      allocation,
-      (0, import_common.toTxObject)(tx, guard),
-      (0, import_common.toTxObject)(tx, passport),
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [allocation_type]
-  });
+    (0, util_js_1.validObjects)([allocation, guard, passport]);
+    if (!(0, common_js_1.IsValidArgType)(allocation_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
+    tx.moveCall({
+        target: allocationFn("alloc"),
+        arguments: [
+            allocation,
+            (0, common_js_1.toTxObject)(tx, guard),
+            (0, common_js_1.toTxObject)(tx, passport),
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: [allocation_type],
+    });
 }
-function newAllocation(tx, allocation_type, coin, allocators2) {
-  (0, import_util.validObjects)([coin, allocators2]);
-  return tx.moveCall({
-    target: allocationFn("new_with_coin"),
-    arguments: [
-      coin,
-      allocators2,
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [allocation_type]
-  });
+function newAllocation(tx, allocation_type, coin, allocators) {
+    (0, util_js_1.validObjects)([coin, allocators]);
+    return tx.moveCall({
+        target: allocationFn("new_with_coin"),
+        arguments: [
+            coin,
+            allocators,
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: [allocation_type],
+    });
 }
-function create(tx, allocation, allocation_type, paymentInfo2) {
-  (0, import_util.validObjects)([allocation, paymentInfo2]);
-  if (!(0, import_common.IsValidArgType)(allocation_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  return tx.moveCall({
-    target: allocationFn("create"),
-    arguments: [allocation, (0, import_common.toTxObject)(tx, paymentInfo2)],
-    typeArguments: [allocation_type]
-  });
+function create(tx, allocation, allocation_type, paymentInfo) {
+    (0, util_js_1.validObjects)([allocation, paymentInfo]);
+    if (!(0, common_js_1.IsValidArgType)(allocation_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
+    return tx.moveCall({
+        target: allocationFn("create"),
+        arguments: [allocation, (0, common_js_1.toTxObject)(tx, paymentInfo)],
+        typeArguments: [allocation_type],
+    });
 }
 function receive(tx, allocation, allocation_type, received, payment) {
-  (0, import_util.validObjects)([allocation, payment, received]);
-  if (!(0, import_common.IsValidArgType)(allocation_type)) {
-    (0, import_exception.W_ERROR)(
-      import_exception.WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  return tx.moveCall({
-    target: allocationFn("receive"),
-    arguments: [
-      allocation,
-      (0, import_common.toTxObject)(tx, received),
-      (0, import_common.toTxObject)(tx, payment)
-    ],
-    typeArguments: [allocation_type]
-  });
+    (0, util_js_1.validObjects)([allocation, payment, received]);
+    if (!(0, common_js_1.IsValidArgType)(allocation_type)) {
+        (0, exception_js_1.W_ERROR)(exception_js_1.WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
+    return tx.moveCall({
+        target: allocationFn("receive"),
+        arguments: [
+            allocation,
+            (0, common_js_1.toTxObject)(tx, received),
+            (0, common_js_1.toTxObject)(tx, payment),
+        ],
+        typeArguments: [allocation_type],
+    });
 }
+//# sourceMappingURL=allocation.js.map