wowok 2.1.10 → 2.1.13

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

@@ -1,23 +1,9 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+// Copyright (c) Wowok.
+// SPDX-License-Identifier: Apache-2.0
 import { isValidWowAddress } from "../../utils/sui-types.js";
-import {
-  toTxObject,
-  isValidDescription,
-  MAX_DESCRIPTION_LENGTH,
-  PackageAddress,
-  isValidU8,
-  isValidU64,
-  GetObjectExisted,
-  GetObject,
-  IsValidArgType
-} from "../common.js";
+import { toTxObject, isValidDescription, MAX_DESCRIPTION_LENGTH, PackageAddress, isValidU8, isValidU64, GetObjectExisted, GetObject, IsValidArgType, } from "../common.js";
 import { W_ERROR, WErrors } from "../exception.js";
-import {
-  GetAccountOrMark_Address,
-  GetManyAccountOrMark_Address
-} from "../local/index.js";
+import { GetAccountOrMark_Address, GetManyAccountOrMark_Address, } from "../local/index.js";
 import { LocalMark } from "../local/local.js";
 import { ObjectType } from "../query/object.js";
 import { query_received } from "../query/received.js";
@@ -25,409 +11,328 @@ import { parseObjectType, validObjects } from "../util.js";
 import { CallBase, getCoinParam } from "./base.js";
 import { get_guardSubmissions } from "./passport.js";
 import { paymentInfo } from "./payment.js";
-class CallAllocation extends 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 GetObjectExisted(this.data?.object);
+export class CallAllocation extends 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,
-        ObjectType.Allocation,
-        this.object_address
-      );
-      if (!this.content) {
-        W_ERROR(
-          WErrors.InvalidParam,
-          "CallAllocation_Data.data.object:" + this.object_address
-        );
-      }
-      this.type_parameter = parseObjectType(
-        this.content.type_raw,
-        "allocation::Allocation"
-      );
-      if (!this.type_parameter) {
-        W_ERROR(
-          WErrors.IsValidArgType,
-          "CallAllocation_Data.data.object.type_parameter is empty"
-        );
-      }
-    } else {
-      const n = GetObject(this.data.object);
-      if (!n || !IsValidArgType(n?.type_parameter)) {
-        W_ERROR(
-          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 LocalMark.Instance().get_address(
-        this.data.alloc_by_guard
-      );
-      if (!g || !isValidWowAddress(g)) {
-        W_ERROR(
-          WErrors.IsValidAddress,
-          `alloc_by_guard: ${this.data.alloc_by_guard}`
-        );
-      }
-      if (this.content && !this.content.allocators.find(
-        (item) => item.guard === g
-      )) {
-        W_ERROR(
-          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 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 GetObjectExisted(this.data?.object);
+        }
+        if (this.object_address) {
+            await this.update_content(env, ObjectType.Allocation, this.object_address);
+            if (!this.content) {
+                W_ERROR(WErrors.InvalidParam, "CallAllocation_Data.data.object:" + this.object_address);
+            }
+            this.type_parameter = parseObjectType(this.content.type_raw, "allocation::Allocation");
+            if (!this.type_parameter) {
+                W_ERROR(WErrors.IsValidArgType, "CallAllocation_Data.data.object.type_parameter is empty");
+            }
+        }
+        else {
+            const n = GetObject(this.data.object);
+            if (!n || !IsValidArgType(n?.type_parameter)) {
+                W_ERROR(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 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.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 LocalMark.Instance().get_address(this.data.alloc_by_guard);
+            if (!g || !isValidWowAddress(g)) {
+                W_ERROR(WErrors.IsValidAddress, `alloc_by_guard: ${this.data.alloc_by_guard}`);
+            }
+            if (this.content &&
+                !this.content.allocators.find((item) => item.guard === g)) {
+                W_ERROR(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 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) {
-            W_ERROR(
-              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 (!isValidWowAddress(v.id) || !isValidWowAddress(v.payment)) {
-              W_ERROR(
-                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 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.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) {
+                        W_ERROR(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 (!isValidWowAddress(v.id) ||
+                            !isValidWowAddress(v.payment)) {
+                            W_ERROR(WErrors.InvalidParam, "CallAllocation_Data.data.received_coins:" +
+                                v.id);
+                        }
+                        receive(tx, toTxObject(tx, this.object_address), this.type_parameter, toTxObject(tx, v.id), toTxObject(tx, v.payment));
+                    }
+                }
+            }
+            if ("alloc_by_guard" in this.data &&
+                this.data.alloc_by_guard != null) {
+                if (!passport) {
+                    W_ERROR(WErrors.InvalidParam, "CallAllocation_Data.data.alloc_by_guard:" +
+                        this.data.alloc_by_guard);
+                }
+                alloc(tx, toTxObject(tx, this.object_address), this.type_parameter, this.data.alloc_by_guard, passport);
             }
-            receive(
-              tx,
-              toTxObject(tx, this.object_address),
-              this.type_parameter,
-              toTxObject(tx, v.id),
-              toTxObject(tx, v.payment)
-            );
-          }
         }
-      }
-      if ("alloc_by_guard" in this.data && this.data.alloc_by_guard != null) {
-        if (!passport) {
-          W_ERROR(
-            WErrors.InvalidParam,
-            "CallAllocation_Data.data.alloc_by_guard:" + this.data.alloc_by_guard
-          );
+        else {
+            const n = GetObject(this.data.object);
+            if (!IsValidArgType(n?.type_parameter)) {
+                W_ERROR(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 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, ObjectType.Allocation, create(tx, allocation, this.type_parameter, await paymentInfo(env, tx, this.data.payment_info)), n);
+            }
+            else {
+                W_ERROR(WErrors.InvalidParam, `CallAllocation_Data.data ${JSON.stringify(this.data)}`);
+            }
         }
-        alloc(
-          tx,
-          toTxObject(tx, this.object_address),
-          this.type_parameter,
-          this.data.alloc_by_guard,
-          passport
-        );
-      }
-    } else {
-      const n = GetObject(this.data.object);
-      if (!IsValidArgType(n?.type_parameter)) {
-        W_ERROR(
-          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 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,
-          ObjectType.Allocation,
-          create(
-            tx,
-            allocation,
-            this.type_parameter,
-            await paymentInfo(env, tx, this.data.payment_info)
-          ),
-          n
-        );
-      } else {
-        W_ERROR(
-          WErrors.InvalidParam,
-          `CallAllocation_Data.data ${JSON.stringify(this.data)}`
-        );
-      }
     }
-  }
 }
-function allocationFn(name) {
-  return `${PackageAddress}::allocation::${name}`;
+// ================================================
+export function allocationFn(name) {
+    return `${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 (!isValidU8(sharing2.who.GuardIdentifier)) {
-      W_ERROR(
-        WErrors.IsValidU8,
-        `sharing GuardIdentifier: ${sharing2.who.GuardIdentifier}`
-      );
+export const MAX_ALLOCATOR_COUNT = 100;
+export const MAX_SHARING_COUNT = 100;
+// ================================================
+export const sharing = async (tx, sharing, preResolvedAddress) => {
+    if ("GuardIdentifier" in sharing.who) {
+        if (!isValidU8(sharing.who.GuardIdentifier)) {
+            W_ERROR(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 GetAccountOrMark_Address(sharing2.who.Entity);
-    if (!addr) {
-      W_ERROR(
-        WErrors.IsValidAddress,
-        `sharing Entity: ${sharing2.who.Entity}`
-      );
+    else if ("Entity" in sharing.who) {
+        const addr = preResolvedAddress ||
+            (await GetAccountOrMark_Address(sharing.who.Entity));
+        if (!addr) {
+            W_ERROR(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))
-      ]
-    });
-  }
 };
-const allocators = async (tx, param) => {
-  if (!isValidDescription(param.description)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`
-    );
-  }
-  if (param.allocators.length > MAX_ALLOCATOR_COUNT) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `Allocator count exceeds maximum limit ${MAX_ALLOCATOR_COUNT}`
-    );
-  }
-  if (param.allocators.length === 0) {
-    W_ERROR(WErrors.InvalidParam, `Allocator array cannot be empty`);
-  }
-  if (!isValidU64(param.threshold)) {
-    W_ERROR(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) {
-      W_ERROR(WErrors.InvalidParam, `sharing array cannot be empty`);
+export const allocators = async (tx, param) => {
+    if (!isValidDescription(param.description)) {
+        W_ERROR(WErrors.InvalidParam, `Description exceeds maximum length ${MAX_DESCRIPTION_LENGTH}`);
     }
-    if (allocator.sharing.length > MAX_SHARING_COUNT) {
-      W_ERROR(
-        WErrors.InvalidParam,
-        `sharing count exceeds maximum limit ${MAX_SHARING_COUNT}`
-      );
+    if (param.allocators.length > MAX_ALLOCATOR_COUNT) {
+        W_ERROR(WErrors.InvalidParam, `Allocator count exceeds maximum limit ${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([
-      LocalMark.Instance().get_address(allocator.guard),
-      // 只转换 Entity 类型
-      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) {
-      W_ERROR(WErrors.IsValidAddress, `guard: ${allocator.guard}`);
+    if (param.allocators.length === 0) {
+        W_ERROR(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) {
-            W_ERROR(
-              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: `${PackageAddress}::allocation::Sharing`
-      //@ must specify type
+    if (!isValidU64(param.threshold)) {
+        W_ERROR(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),
+        ],
     });
+    for (let i = 0; i < param.allocators.length; i++) {
+        const allocator = param.allocators[i];
+        if (allocator.sharing.length === 0) {
+            W_ERROR(WErrors.InvalidParam, `sharing array cannot be empty`);
+        }
+        if (allocator.sharing.length > MAX_SHARING_COUNT) {
+            W_ERROR(WErrors.InvalidParam, `sharing count exceeds maximum limit ${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([
+            LocalMark.Instance().get_address(allocator.guard),
+            // 只转换 Entity 类型
+            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) {
+            W_ERROR(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) {
+                    W_ERROR(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);
+            }
+        }));
+        // 使用 tx.makeMoveVec 创建向量，它会自动处理元素类型转换
+        const makeMoveVecResult = tx.makeMoveVec({
+            elements: sharingElements,
+            type: `${PackageAddress}::allocation::Sharing`, //@ must specify type
+        });
+        tx.moveCall({
+            target: allocationFn("allocator_add"),
+            arguments: [
+                allocators_obj,
+                toTxObject(tx, g),
+                makeMoveVecResult,
+                tx.pure.option("u64", allocator?.max),
+            ],
+        });
+    }
+    return allocators_obj;
+};
+export function alloc(tx, allocation, allocation_type, guard, passport) {
+    validObjects([allocation, guard, passport]);
+    if (!IsValidArgType(allocation_type)) {
+        W_ERROR(WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
     tx.moveCall({
-      target: allocationFn("allocator_add"),
-      arguments: [
-        allocators_obj,
-        toTxObject(tx, g),
-        makeMoveVecResult,
-        tx.pure.option("u64", allocator?.max)
-      ]
+        target: allocationFn("alloc"),
+        arguments: [
+            allocation,
+            toTxObject(tx, guard),
+            toTxObject(tx, passport),
+            tx.object.mutRegistrar(),
+            tx.object.clock(),
+        ],
+        typeArguments: [allocation_type],
     });
-  }
-  return allocators_obj;
-};
-function alloc(tx, allocation, allocation_type, guard, passport) {
-  validObjects([allocation, guard, passport]);
-  if (!IsValidArgType(allocation_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  tx.moveCall({
-    target: allocationFn("alloc"),
-    arguments: [
-      allocation,
-      toTxObject(tx, guard),
-      toTxObject(tx, passport),
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [allocation_type]
-  });
 }
-function newAllocation(tx, allocation_type, coin, allocators2) {
-  validObjects([coin, allocators2]);
-  return tx.moveCall({
-    target: allocationFn("new_with_coin"),
-    arguments: [
-      coin,
-      allocators2,
-      tx.object.mutRegistrar(),
-      tx.object.clock()
-    ],
-    typeArguments: [allocation_type]
-  });
+export function newAllocation(tx, allocation_type, coin, allocators) {
+    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) {
-  validObjects([allocation, paymentInfo2]);
-  if (!IsValidArgType(allocation_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  return tx.moveCall({
-    target: allocationFn("create"),
-    arguments: [allocation, toTxObject(tx, paymentInfo2)],
-    typeArguments: [allocation_type]
-  });
+export function create(tx, allocation, allocation_type, paymentInfo) {
+    validObjects([allocation, paymentInfo]);
+    if (!IsValidArgType(allocation_type)) {
+        W_ERROR(WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
+    return tx.moveCall({
+        target: allocationFn("create"),
+        arguments: [allocation, toTxObject(tx, paymentInfo)],
+        typeArguments: [allocation_type],
+    });
 }
-function receive(tx, allocation, allocation_type, received, payment) {
-  validObjects([allocation, payment, received]);
-  if (!IsValidArgType(allocation_type)) {
-    W_ERROR(
-      WErrors.InvalidParam,
-      `allocation_type: ${allocation_type} invalid`
-    );
-  }
-  return tx.moveCall({
-    target: allocationFn("receive"),
-    arguments: [
-      allocation,
-      toTxObject(tx, received),
-      toTxObject(tx, payment)
-    ],
-    typeArguments: [allocation_type]
-  });
+export function receive(tx, allocation, allocation_type, received, payment) {
+    validObjects([allocation, payment, received]);
+    if (!IsValidArgType(allocation_type)) {
+        W_ERROR(WErrors.InvalidParam, `allocation_type: ${allocation_type} invalid`);
+    }
+    return tx.moveCall({
+        target: allocationFn("receive"),
+        arguments: [
+            allocation,
+            toTxObject(tx, received),
+            toTxObject(tx, payment),
+        ],
+        typeArguments: [allocation_type],
+    });
 }
-export {
-  CallAllocation,
-  MAX_ALLOCATOR_COUNT,
-  MAX_SHARING_COUNT,
-  alloc,
-  allocationFn,
-  allocators,
-  create,
-  newAllocation,
-  receive,
-  sharing
-};
+//# sourceMappingURL=allocation.js.map